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

ItEr26S06RFControlAvancesIncompatiblesEnUnidadesTraballoItEr25S06: Fixing typo ("assigment" instead of "assignment").

Browse source
This commit is contained in:
Manuel Rego Casasnovas 2009-09-17 16:10:44 +02:00 • committed by Javier Moran Rua
parent 25734e7132
commit 12fa46a9d6
52 changed files with 843 additions and 843 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
ganttzk-demo-webapp/src/main/webapp/planner/main.zul
View file

@ -16,7 +16,7 @@
-->
<planner id="planner" self="@{define(content)}"
configuration="${plannerData.lightLoad}">
<div id="idContextMenuTaskAssigment"></div>
<div id="idContextMenuTaskAssignment"></div>
</planner>
<popup width="300px" apply="${plannerData.taskEditForm}">

4
ganttzk/src/main/java/org/zkoss/ganttz/TaskAssigmentMoveCommand.java → ganttzk/src/main/java/org/zkoss/ganttz/TaskAssignmentMoveCommand.java
View file

@ -8,9 +8,9 @@ import org.zkoss.zk.au.Command;
* @author Francisco Javier Moran Rúa
*
*/
public class TaskAssigmentMoveCommand extends Command {
public class TaskAssignmentMoveCommand extends Command {
public TaskAssigmentMoveCommand(String event,int flags) {
public TaskAssignmentMoveCommand(String event,int flags) {
super(event,flags);
}

2
ganttzk/src/main/java/org/zkoss/ganttz/TaskComponent.java
View file

@ -137,7 +137,7 @@ public class TaskComponent extends Div implements AfterCompose {
public TaskComponent(Task task) {
setHeight(HEIGHT_PER_TASK + "px");
setContext("idContextMenuTaskAssigment");
setContext("idContextMenuTaskAssignment");
this.task = task;
setColor(STANDARD_TASK_COLOR);
setId(UUID.randomUUID().toString());

2
ganttzk/src/main/resources/web/ganttz/css/task.css.dsp
View file

@ -1,5 +1,5 @@
<style>
.z-taskassigment-normal {
.z-taskassignment-normal {
cursos: move;
border: 2px solid #538BA2;
background-color: #BBBBBB;

10
navalplanner-business/src/main/java/org/navalplanner/business/advance/daos/AdvanceAssigmentDAO.java → navalplanner-business/src/main/java/org/navalplanner/business/advance/daos/AdvanceAssignmentDAO.java
View file

@ -1,18 +1,18 @@
package org.navalplanner.business.advance.daos;
import org.navalplanner.business.advance.entities.AdvanceAssigment;
import org.navalplanner.business.advance.entities.AdvanceAssignment;
import org.navalplanner.business.common.daos.GenericDAOHibernate;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Repository;
/**
* Dao for {@link AdvanceAssigment}
* Dao for {@link AdvanceAssignment}
* @author Susana Montes Pedreira <smontes@wirelessgalicia.com>
*/
@Repository
@Scope(BeanDefinition.SCOPE_SINGLETON)
public class AdvanceAssigmentDAO extends
GenericDAOHibernate<AdvanceAssigment, Long> implements
IAdvanceAssigmentDAO {
public class AdvanceAssignmentDAO extends
GenericDAOHibernate<AdvanceAssignment, Long> implements
IAdvanceAssignmentDAO {
}

12
navalplanner-business/src/main/java/org/navalplanner/business/advance/daos/IAdvanceAssigmentDAO.java
View file

@ -1,12 +0,0 @@
package org.navalplanner.business.advance.daos;
import org.navalplanner.business.advance.entities.AdvanceAssigment;
import org.navalplanner.business.common.daos.IGenericDAO;
/**
* Contract for {@link AdvanceAssigmentDao}
* @author Susana Montes Pedreira <smontes@wirelessgalicia.com>
*/
public interface IAdvanceAssigmentDAO extends IGenericDAO<AdvanceAssigment, Long> {
}

12
navalplanner-business/src/main/java/org/navalplanner/business/advance/daos/IAdvanceAssignmentDAO.java Normal file
View file

@ -0,0 +1,12 @@
package org.navalplanner.business.advance.daos;
import org.navalplanner.business.advance.entities.AdvanceAssignment;
import org.navalplanner.business.common.daos.IGenericDAO;
/**
* Contract for {@link AdvanceAssignmentDao}
* @author Susana Montes Pedreira <smontes@wirelessgalicia.com>
*/
public interface IAdvanceAssignmentDAO extends IGenericDAO<AdvanceAssignment, Long> {
}

22
navalplanner-business/src/main/java/org/navalplanner/business/advance/entities/AdvanceAssigment.java → navalplanner-business/src/main/java/org/navalplanner/business/advance/entities/AdvanceAssignment.java
View file

@ -9,20 +9,20 @@ import org.joda.time.LocalDate;
import org.navalplanner.business.common.BaseEntity;
import org.navalplanner.business.orders.entities.OrderElement;
public class AdvanceAssigment extends BaseEntity {
public class AdvanceAssignment extends BaseEntity {
public enum Type { DIRECT, CALCULATED };
public static AdvanceAssigment create() {
AdvanceAssigment advanceAssigment = new AdvanceAssigment();
advanceAssigment.setNewObject(true);
return advanceAssigment;
public static AdvanceAssignment create() {
AdvanceAssignment advanceAssignment = new AdvanceAssignment();
advanceAssignment.setNewObject(true);
return advanceAssignment;
}
public static AdvanceAssigment create(boolean reportGlobalAdvance, BigDecimal maxValue) {
AdvanceAssigment advanceAssigment = new AdvanceAssigment(reportGlobalAdvance, maxValue);
advanceAssigment.setNewObject(true);
return advanceAssigment;
public static AdvanceAssignment create(boolean reportGlobalAdvance, BigDecimal maxValue) {
AdvanceAssignment advanceAssignment = new AdvanceAssignment(reportGlobalAdvance, maxValue);
advanceAssignment.setNewObject(true);
return advanceAssignment;
}
private boolean reportGlobalAdvance;
@ -39,11 +39,11 @@ public class AdvanceAssigment extends BaseEntity {
private SortedSet<AdvanceMeasurement> advanceMeasurements =
new TreeSet<AdvanceMeasurement>(new AdvanceMeasurementComparator());
public AdvanceAssigment() {
public AdvanceAssignment() {
this.reportGlobalAdvance = false;
}
private AdvanceAssigment(boolean reportGlobalAdvance,BigDecimal maxValue) {
private AdvanceAssignment(boolean reportGlobalAdvance,BigDecimal maxValue) {
this.reportGlobalAdvance = reportGlobalAdvance;
this.maxValue = maxValue;
this.maxValue.setScale(2,BigDecimal.ROUND_HALF_UP);

10
navalplanner-business/src/main/java/org/navalplanner/business/advance/entities/AdvanceMeasurement.java
View file

@ -28,7 +28,7 @@ public class AdvanceMeasurement extends BaseEntity {
private BigDecimal value;
@NotNull
private AdvanceAssigment advanceAssigment;
private AdvanceAssignment advanceAssignment;
public AdvanceMeasurement() {
}
@ -56,12 +56,12 @@ public class AdvanceMeasurement extends BaseEntity {
return this.value;
}
public void setAdvanceAssigment(AdvanceAssigment advanceAssigment) {
this.advanceAssigment = advanceAssigment;
public void setAdvanceAssignment(AdvanceAssignment advanceAssignment) {
this.advanceAssignment = advanceAssignment;
}
public AdvanceAssigment getAdvanceAssigment() {
return this.advanceAssigment;
public AdvanceAssignment getAdvanceAssignment() {
return this.advanceAssignment;
}
}

8
navalplanner-business/src/main/java/org/navalplanner/business/advance/exceptions/DuplicateAdvanceAssigmentForOrderElementException.java → navalplanner-business/src/main/java/org/navalplanner/business/advance/exceptions/DuplicateAdvanceAssignmentForOrderElementException.java
View file

@ -2,19 +2,19 @@ package org.navalplanner.business.advance.exceptions;
/**
* An exception for modeling a problem with duplicated advance assigment of the
* An exception for modeling a problem with duplicated advance assignment of the
* same type for an order element. It contains a message, the key of the
* instance, and its class name.
* @author Susana Montes Pedreira <smontes@wirelessgalicia.com>
*/
@SuppressWarnings("serial")
public class DuplicateAdvanceAssigmentForOrderElementException extends
public class DuplicateAdvanceAssignmentForOrderElementException extends
Exception {
private Object key;
private String className;
public DuplicateAdvanceAssigmentForOrderElementException(
public DuplicateAdvanceAssignmentForOrderElementException(
String specificMessage, Object key, String className) {
super(specificMessage + " (key = '" + key + "' - className = '"
+ className + "')");
@ -22,7 +22,7 @@ public class DuplicateAdvanceAssigmentForOrderElementException extends
this.className = className;
}
public DuplicateAdvanceAssigmentForOrderElementException(
public DuplicateAdvanceAssignmentForOrderElementException(
String specificMessage, Object key, Class<?> klass) {
this(specificMessage, key, klass.getName());
}

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

@ -9,9 +9,9 @@ import java.util.Set;
import org.apache.commons.lang.Validate;
import org.hibernate.validator.NotEmpty;
import org.navalplanner.business.advance.entities.AdvanceAssigment;
import org.navalplanner.business.advance.entities.AdvanceAssignment;
import org.navalplanner.business.advance.entities.AdvanceType;
import org.navalplanner.business.advance.exceptions.DuplicateAdvanceAssigmentForOrderElementException;
import org.navalplanner.business.advance.exceptions.DuplicateAdvanceAssignmentForOrderElementException;
import org.navalplanner.business.advance.exceptions.DuplicateValueTrueReportGlobalAdvanceException;
import org.navalplanner.business.common.BaseEntity;
import org.navalplanner.business.labels.entities.Label;
@ -32,7 +32,7 @@ public abstract class OrderElement extends BaseEntity {
private String description;
protected Set<AdvanceAssigment> advanceAssigments = new HashSet<AdvanceAssigment>();
protected Set<AdvanceAssignment> advanceAssignments = new HashSet<AdvanceAssignment>();
private Set<Label> labels = new HashSet<Label>();
@ -147,14 +147,14 @@ public abstract class OrderElement extends BaseEntity {
return code;
}
public abstract Set<AdvanceAssigment> getAdvanceAssigments();
public abstract Set<AdvanceAssignment> getAdvanceAssignments();
protected Set<AdvanceAssigment> getAdvanceAssigmentsWithoutMerge() {
return Collections.unmodifiableSet(this.advanceAssigments);
protected Set<AdvanceAssignment> getAdvanceAssignmentsWithoutMerge() {
return Collections.unmodifiableSet(this.advanceAssignments);
}
public void removeAdvanceAssigment(AdvanceAssigment advanceAssigment) {
advanceAssigments.remove(advanceAssigment);
public void removeAdvanceAssignment(AdvanceAssignment advanceAssignment) {
advanceAssignments.remove(advanceAssignment);
}
public Set<Label> getLabels() {
@ -171,35 +171,35 @@ public abstract class OrderElement extends BaseEntity {
}
/**
* Validate if the advanceAssigment can be added to the order element.The
* list of advanceAssigments must be attached.
* @param advanceAssigment
* Validate if the advanceAssignment can be added to the order element.The
* list of advanceAssignments must be attached.
* @param advanceAssignment
* must be attached
* @throws DuplicateValueTrueReportGlobalAdvanceException
* @throws DuplicateAdvanceAssigmentForOrderElementException
* @throws DuplicateAdvanceAssignmentForOrderElementException
*/
public void addAdvanceAssigment(AdvanceAssigment newAdvanceAssigment)
public void addAdvanceAssignment(AdvanceAssignment newAdvanceAssignment)
throws DuplicateValueTrueReportGlobalAdvanceException,
DuplicateAdvanceAssigmentForOrderElementException {
if(newAdvanceAssigment.getType().equals(AdvanceAssigment.Type.DIRECT)){
checkNoOtherGlobalAdvanceAssignment(newAdvanceAssigment);
DuplicateAdvanceAssignmentForOrderElementException {
if(newAdvanceAssignment.getType().equals(AdvanceAssignment.Type.DIRECT)){
checkNoOtherGlobalAdvanceAssignment(newAdvanceAssignment);
checkAncestorsNoOtherAssignmentWithSameAdvanceType(this,
newAdvanceAssigment);
newAdvanceAssignment);
checkChildrenNoOtherAssignmentWithSameAdvanceType(this,
newAdvanceAssigment);
newAdvanceAssignment);
}
this.advanceAssigments.add(newAdvanceAssigment);
this.advanceAssignments.add(newAdvanceAssignment);
}
private void checkNoOtherGlobalAdvanceAssignment(
AdvanceAssigment newAdvanceAssigment)
AdvanceAssignment newAdvanceAssignment)
throws DuplicateValueTrueReportGlobalAdvanceException {
if (!newAdvanceAssigment.getReportGlobalAdvance()) {
if (!newAdvanceAssignment.getReportGlobalAdvance()) {
return;
}
for (AdvanceAssigment advanceAssigment : advanceAssigments) {
if((advanceAssigment.getType().equals(AdvanceAssigment.Type.DIRECT))
&& (advanceAssigment.getReportGlobalAdvance()))
for (AdvanceAssignment advanceAssignment : advanceAssignments) {
if((advanceAssignment.getType().equals(AdvanceAssignment.Type.DIRECT))
&& (advanceAssignment.getReportGlobalAdvance()))
throw new DuplicateValueTrueReportGlobalAdvanceException(
"Duplicate Value True ReportGlobalAdvance For Order Element",
this, OrderElement.class);
@ -207,53 +207,53 @@ public abstract class OrderElement extends BaseEntity {
}
/**
* It checks there are no {@link AdvanceAssigment} with the same type in
* It checks there are no {@link AdvanceAssignment} with the same type in
* orderElement and ancestors
* @param orderElement
* @param newAdvanceAssigment
* @throws DuplicateAdvanceAssigmentForOrderElementException
* @param newAdvanceAssignment
* @throws DuplicateAdvanceAssignmentForOrderElementException
*/
private void checkAncestorsNoOtherAssignmentWithSameAdvanceType(
OrderElement orderElement, AdvanceAssigment newAdvanceAssigment)
throws DuplicateAdvanceAssigmentForOrderElementException {
for (AdvanceAssigment advanceAssigment : orderElement.advanceAssigments) {
if ((AdvanceType.equivalentInDB(advanceAssigment.getAdvanceType(),
newAdvanceAssigment.getAdvanceType())) &&
(advanceAssigment.getType().equals(AdvanceAssigment.Type.DIRECT))) {
throw new DuplicateAdvanceAssigmentForOrderElementException(
"Duplicate Advance Assigment For Order Element", this,
OrderElement orderElement, AdvanceAssignment newAdvanceAssignment)
throws DuplicateAdvanceAssignmentForOrderElementException {
for (AdvanceAssignment advanceAssignment : orderElement.advanceAssignments) {
if ((AdvanceType.equivalentInDB(advanceAssignment.getAdvanceType(),
newAdvanceAssignment.getAdvanceType())) &&
(advanceAssignment.getType().equals(AdvanceAssignment.Type.DIRECT))) {
throw new DuplicateAdvanceAssignmentForOrderElementException(
"Duplicate Advance Assignment For Order Element", this,
OrderElement.class);
}
}
if (orderElement.getParent() != null) {
checkAncestorsNoOtherAssignmentWithSameAdvanceType(orderElement
.getParent(), newAdvanceAssigment);
.getParent(), newAdvanceAssignment);
}
}
/**
* It checks there are no {@link AdvanceAssigment} with the same type in
* It checks there are no {@link AdvanceAssignment} with the same type in
* orderElement and its children
* @param orderElement
* @param newAdvanceAssigment
* @throws DuplicateAdvanceAssigmentForOrderElementException
* @param newAdvanceAssignment
* @throws DuplicateAdvanceAssignmentForOrderElementException
*/
private void checkChildrenNoOtherAssignmentWithSameAdvanceType(
OrderElement orderElement, AdvanceAssigment newAdvanceAssigment)
throws DuplicateAdvanceAssigmentForOrderElementException {
for (AdvanceAssigment advanceAssigment : orderElement.advanceAssigments) {
if ((AdvanceType.equivalentInDB(advanceAssigment.getAdvanceType(),
newAdvanceAssigment.getAdvanceType())) &&
(advanceAssigment.getType().equals(AdvanceAssigment.Type.DIRECT))) {
throw new DuplicateAdvanceAssigmentForOrderElementException(
"Duplicate Advance Assigment For Order Element", this,
OrderElement orderElement, AdvanceAssignment newAdvanceAssignment)
throws DuplicateAdvanceAssignmentForOrderElementException {
for (AdvanceAssignment advanceAssignment : orderElement.advanceAssignments) {
if ((AdvanceType.equivalentInDB(advanceAssignment.getAdvanceType(),
newAdvanceAssignment.getAdvanceType())) &&
(advanceAssignment.getType().equals(AdvanceAssignment.Type.DIRECT))) {
throw new DuplicateAdvanceAssignmentForOrderElementException(
"Duplicate Advance Assignment For Order Element", this,
OrderElement.class);
}
}
if (!orderElement.getChildren().isEmpty()) {
for (OrderElement child : orderElement.getChildren()) {
checkChildrenNoOtherAssignmentWithSameAdvanceType(child,
newAdvanceAssigment);
newAdvanceAssignment);
}
}
}

14
navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/OrderLine.java
View file

@ -6,7 +6,7 @@ import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.navalplanner.business.advance.entities.AdvanceAssigment;
import org.navalplanner.business.advance.entities.AdvanceAssignment;
public class OrderLine extends OrderElement {
@ -346,15 +346,15 @@ public class OrderLine extends OrderElement {
@Override
public BigDecimal getAdvancePercentage() {
Set<AdvanceAssigment> advanceAssigments = getAdvanceAssigments();
Set<AdvanceAssignment> advanceAssignments = getAdvanceAssignments();
BigDecimal temp = new BigDecimal(0);
for (AdvanceAssigment advanceAssigment : advanceAssigments) {
BigDecimal percentage = advanceAssigment.getLastPercentage();
for (AdvanceAssignment advanceAssignment : advanceAssignments) {
BigDecimal percentage = advanceAssignment.getLastPercentage();
temp = temp.add(percentage);
}
Integer number = advanceAssigments.size();
Integer number = advanceAssignments.size();
if (number > 0) {
temp = temp.divide(new BigDecimal(number));
}
@ -363,8 +363,8 @@ public class OrderLine extends OrderElement {
}
@Override
public Set<AdvanceAssigment> getAdvanceAssigments() {
return getAdvanceAssigmentsWithoutMerge();
public Set<AdvanceAssignment> getAdvanceAssignments() {
return getAdvanceAssignmentsWithoutMerge();
}
}

94
navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/OrderLineGroup.java
View file

@ -14,10 +14,10 @@ import java.util.TreeSet;
import org.hibernate.validator.Valid;
import org.joda.time.LocalDate;
import org.navalplanner.business.advance.entities.AdvanceAssigment;
import org.navalplanner.business.advance.entities.AdvanceAssignment;
import org.navalplanner.business.advance.entities.AdvanceMeasurement;
import org.navalplanner.business.advance.entities.AdvanceMeasurementComparator;
import org.navalplanner.business.advance.entities.AdvanceAssigment.Type;
import org.navalplanner.business.advance.entities.AdvanceAssignment.Type;
public class OrderLineGroup extends OrderElement implements IOrderLineGroup {
@ -135,14 +135,14 @@ public class OrderLineGroup extends OrderElement implements IOrderLineGroup {
temp = temp.divide(new BigDecimal(hours));
}
Set<AdvanceAssigment> advanceAssigments = this.advanceAssigments;
if (!advanceAssigments.isEmpty()) {
for (AdvanceAssigment advanceAssigment : advanceAssigments) {
BigDecimal percentage = advanceAssigment.getLastPercentage();
Set<AdvanceAssignment> advanceAssignments = this.advanceAssignments;
if (!advanceAssignments.isEmpty()) {
for (AdvanceAssignment advanceAssignment : advanceAssignments) {
BigDecimal percentage = advanceAssignment.getLastPercentage();
temp = temp.add(percentage);
}
Integer number = advanceAssigments.size() + 1;
Integer number = advanceAssignments.size() + 1;
temp = temp.divide(new BigDecimal(number));
}
@ -150,76 +150,76 @@ public class OrderLineGroup extends OrderElement implements IOrderLineGroup {
}
@Override
public Set<AdvanceAssigment> getAdvanceAssigments() {
Set<AdvanceAssigment> assigments = new HashSet<AdvanceAssigment>();
public Set<AdvanceAssignment> getAdvanceAssignments() {
Set<AdvanceAssignment> assignments = new HashSet<AdvanceAssignment>();
for (OrderElement child : children) {
assigments.addAll(child.getAdvanceAssigmentsWithoutMerge());
assignments.addAll(child.getAdvanceAssignmentsWithoutMerge());
}
Map<String, List<AdvanceAssigment>> map = classifyByAdvanceType(assigments);
Map<String, List<AdvanceAssignment>> map = classifyByAdvanceType(assignments);
Set<AdvanceAssigment> result = new HashSet<AdvanceAssigment>();
result.addAll(this.advanceAssigments);
Set<AdvanceAssignment> result = new HashSet<AdvanceAssignment>();
result.addAll(this.advanceAssignments);
for (String advanceType : map.keySet()) {
result.add(mergeAdvanceAssigments(map.get(advanceType)));
result.add(mergeAdvanceAssignments(map.get(advanceType)));
}
return result;
}
private AdvanceAssigment mergeAdvanceAssigments(List<AdvanceAssigment> list) {
private AdvanceAssignment mergeAdvanceAssignments(List<AdvanceAssignment> list) {
if (list.isEmpty()) {
return null;
}
Iterator<AdvanceAssigment> iterator = list.iterator();
AdvanceAssigment origAdvanceAssigment = iterator.next();
AdvanceAssigment advanceAssigment = AdvanceAssigment.create();
advanceAssigment.setMaxValue(origAdvanceAssigment.getMaxValue());
advanceAssigment.setAdvanceType(origAdvanceAssigment.getAdvanceType());
advanceAssigment
.setOrderElement(origAdvanceAssigment.getOrderElement());
advanceAssigment.setAdvanceMeasurements(origAdvanceAssigment
Iterator<AdvanceAssignment> iterator = list.iterator();
AdvanceAssignment origAdvanceAssignment = iterator.next();
AdvanceAssignment advanceAssignment = AdvanceAssignment.create();
advanceAssignment.setMaxValue(origAdvanceAssignment.getMaxValue());
advanceAssignment.setAdvanceType(origAdvanceAssignment.getAdvanceType());
advanceAssignment
.setOrderElement(origAdvanceAssignment.getOrderElement());
advanceAssignment.setAdvanceMeasurements(origAdvanceAssignment
.getAdvanceMeasurements());
advanceAssigment.setType(Type.CALCULATED);
advanceAssignment.setType(Type.CALCULATED);
while (iterator.hasNext()) {
AdvanceAssigment tempAssigment = iterator.next();
BigDecimal maxValue = tempAssigment.getMaxValue();
maxValue = maxValue.add(advanceAssigment.getMaxValue());
advanceAssigment.setMaxValue(maxValue);
AdvanceAssignment tempAssignment = iterator.next();
BigDecimal maxValue = tempAssignment.getMaxValue();
maxValue = maxValue.add(advanceAssignment.getMaxValue());
advanceAssignment.setMaxValue(maxValue);
SortedSet<AdvanceMeasurement> advanceMeasurements = new TreeSet<AdvanceMeasurement>(
new AdvanceMeasurementComparator());
advanceMeasurements.addAll(mergeAdvanceMeasurements(
advanceAssigment,
new ArrayList<AdvanceMeasurement>(advanceAssigment
advanceAssignment,
new ArrayList<AdvanceMeasurement>(advanceAssignment
.getAdvanceMeasurements()),
new ArrayList<AdvanceMeasurement>(tempAssigment
new ArrayList<AdvanceMeasurement>(tempAssignment
.getAdvanceMeasurements())));
advanceAssigment.setAdvanceMeasurements(advanceMeasurements);
advanceAssignment.setAdvanceMeasurements(advanceMeasurements);
}
return advanceAssigment;
return advanceAssignment;
}
private List<AdvanceMeasurement> mergeAdvanceMeasurements(
AdvanceAssigment advanceAssigment, List<AdvanceMeasurement> one,
AdvanceAssignment advanceAssignment, List<AdvanceMeasurement> one,
List<AdvanceMeasurement> other) {
Collections.reverse(one);
Collections.reverse(other);
ArrayList<AdvanceMeasurement> list = new ArrayList<AdvanceMeasurement>();
mergeAdvanceMeasurements(advanceAssigment, one, other, list);
mergeAdvanceMeasurements(advanceAssignment, one, other, list);
return list;
}
private void mergeAdvanceMeasurements(
AdvanceAssigment advanceAssigment,
AdvanceAssignment advanceAssignment,
List<AdvanceMeasurement> list1, List<AdvanceMeasurement> list2,
List<AdvanceMeasurement> result) {
@ -287,7 +287,7 @@ public class OrderLineGroup extends OrderElement implements IOrderLineGroup {
}
AdvanceMeasurement advanceMeasurement = AdvanceMeasurement.create();
advanceMeasurement.setAdvanceAssigment(advanceAssigment);
advanceMeasurement.setAdvanceAssignment(advanceAssignment);
advanceMeasurement.setDate(date);
advanceMeasurement.setValue(previousResult.add(add));
previousResult = advanceMeasurement.getValue();
@ -306,7 +306,7 @@ public class OrderLineGroup extends OrderElement implements IOrderLineGroup {
}
AdvanceMeasurement advanceMeasurement = AdvanceMeasurement.create();
advanceMeasurement.setAdvanceAssigment(advanceAssigment);
advanceMeasurement.setAdvanceAssignment(advanceAssignment);
advanceMeasurement.setDate(date);
advanceMeasurement.setValue(previousResult.add(add));
previousResult = advanceMeasurement.getValue();
@ -325,7 +325,7 @@ public class OrderLineGroup extends OrderElement implements IOrderLineGroup {
}
AdvanceMeasurement advanceMeasurement = AdvanceMeasurement.create();
advanceMeasurement.setAdvanceAssigment(advanceAssigment);
advanceMeasurement.setAdvanceAssignment(advanceAssignment);
advanceMeasurement.setDate(date);
advanceMeasurement.setValue(previousResult.add(add));
previousResult = advanceMeasurement.getValue();
@ -334,19 +334,19 @@ public class OrderLineGroup extends OrderElement implements IOrderLineGroup {
}
private Map<String, List<AdvanceAssigment>> classifyByAdvanceType(
Set<AdvanceAssigment> advanceAssigments) {
Map<String, List<AdvanceAssigment>> map = new HashMap<String, List<AdvanceAssigment>>();
private Map<String, List<AdvanceAssignment>> classifyByAdvanceType(
Set<AdvanceAssignment> advanceAssignments) {
Map<String, List<AdvanceAssignment>> map = new HashMap<String, List<AdvanceAssignment>>();
for (AdvanceAssigment advanceAssigment : advanceAssigments) {
List<AdvanceAssigment> list = map.get(advanceAssigment
for (AdvanceAssignment advanceAssignment : advanceAssignments) {
List<AdvanceAssignment> list = map.get(advanceAssignment
.getAdvanceType().getUnitName());
if (list == null) {
list = new ArrayList<AdvanceAssigment>();
list = new ArrayList<AdvanceAssignment>();
}
list.add(advanceAssigment);
list.add(advanceAssignment);
map.put(advanceAssigment.getAdvanceType().getUnitName(), list);
map.put(advanceAssignment.getAdvanceType().getUnitName(), list);
}
return map;

10
navalplanner-business/src/main/java/org/navalplanner/business/planner/daos/AssigmentFunctionDAO.java → navalplanner-business/src/main/java/org/navalplanner/business/planner/daos/AssignmentFunctionDAO.java
View file

@ -1,20 +1,20 @@
package org.navalplanner.business.planner.daos;
import org.navalplanner.business.common.daos.GenericDAOHibernate;
import org.navalplanner.business.planner.entities.AssigmentFunction;
import org.navalplanner.business.planner.entities.AssignmentFunction;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Repository;
/**
* DAO for {@AssigmentFunction}
* DAO for {@AssignmentFunction}
*
* @author Diego Pino García <dpino@igalia.com>
*/
@Repository
@Scope(BeanDefinition.SCOPE_SINGLETON)
public class AssigmentFunctionDAO extends
GenericDAOHibernate<AssigmentFunction, Long> implements
IAssigmentFunctionDAO {
public class AssignmentFunctionDAO extends
GenericDAOHibernate<AssignmentFunction, Long> implements
IAssignmentFunctionDAO {
}

10
navalplanner-business/src/main/java/org/navalplanner/business/planner/daos/DayAssigmentDAO.java → navalplanner-business/src/main/java/org/navalplanner/business/planner/daos/DayAssignmentDAO.java
View file

@ -1,20 +1,20 @@
package org.navalplanner.business.planner.daos;
import org.navalplanner.business.common.daos.GenericDAOHibernate;
import org.navalplanner.business.planner.entities.DayAssigment;
import org.navalplanner.business.planner.entities.DayAssignment;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Repository;
/**
* DAO for {@DayAssigment}
* DAO for {@DayAssignment}
*
* @author Diego Pino García <dpino@igalia.com>
*/
@Repository
@Scope(BeanDefinition.SCOPE_SINGLETON)
public class DayAssigmentDAO extends
GenericDAOHibernate<DayAssigment, Long> implements
IDayAssigmentDAO {
public class DayAssignmentDAO extends
GenericDAOHibernate<DayAssignment, Long> implements
IDayAssignmentDAO {
}

14
navalplanner-business/src/main/java/org/navalplanner/business/planner/daos/IAssigmentFunctionDAO.java
View file

@ -1,14 +0,0 @@
package org.navalplanner.business.planner.daos;
import org.navalplanner.business.common.daos.IGenericDAO;
import org.navalplanner.business.planner.entities.AssigmentFunction;
/**
* DAO interface for {@link AssigmentFunction}
*
* @author @author Diego Pino García <dpino@igalia.com>
*/
public interface IAssigmentFunctionDAO extends
IGenericDAO<AssigmentFunction, Long> {
}

14
navalplanner-business/src/main/java/org/navalplanner/business/planner/daos/IAssignmentFunctionDAO.java Normal file
View file

@ -0,0 +1,14 @@
package org.navalplanner.business.planner.daos;
import org.navalplanner.business.common.daos.IGenericDAO;
import org.navalplanner.business.planner.entities.AssignmentFunction;
/**
* DAO interface for {@link AssignmentFunction}
*
* @author @author Diego Pino García <dpino@igalia.com>
*/
public interface IAssignmentFunctionDAO extends
IGenericDAO<AssignmentFunction, Long> {
}

14
navalplanner-business/src/main/java/org/navalplanner/business/planner/daos/IDayAssigmentDAO.java
View file

@ -1,14 +0,0 @@
package org.navalplanner.business.planner.daos;
import org.navalplanner.business.common.daos.IGenericDAO;
import org.navalplanner.business.planner.entities.DayAssigment;
/**
* DAO interface for {@link DayAssigment}
*
* @author @author Diego Pino García <dpino@igalia.com>
*/
public interface IDayAssigmentDAO extends
IGenericDAO<DayAssigment, Long> {
}

14
navalplanner-business/src/main/java/org/navalplanner/business/planner/daos/IDayAssignmentDAO.java Normal file
View file

@ -0,0 +1,14 @@
package org.navalplanner.business.planner.daos;
import org.navalplanner.business.common.daos.IGenericDAO;
import org.navalplanner.business.planner.entities.DayAssignment;
/**
* DAO interface for {@link DayAssignment}
*
* @author @author Diego Pino García <dpino@igalia.com>
*/
public interface IDayAssignmentDAO extends
IGenericDAO<DayAssignment, Long> {
}

4
navalplanner-business/src/main/java/org/navalplanner/business/planner/daos/ITaskElementDAO.java
View file

@ -1,7 +1,7 @@
package org.navalplanner.business.planner.daos;
import org.navalplanner.business.common.daos.IGenericDAO;
import org.navalplanner.business.planner.entities.DayAssigment;
import org.navalplanner.business.planner.entities.DayAssignment;
import org.navalplanner.business.planner.entities.TaskElement;
/**
@ -10,7 +10,7 @@ import org.navalplanner.business.planner.entities.TaskElement;
public interface ITaskElementDAO extends IGenericDAO<TaskElement, Long> {
/**
* Removes {@link DayAssigment} that have no parent
* Removes {@link DayAssignment} that have no parent
*/
void removeOrphanedDayAssignments();

26
navalplanner-business/src/main/java/org/navalplanner/business/planner/daos/TaskElementDAO.java
View file

@ -5,9 +5,9 @@ import java.util.List;
import org.hibernate.criterion.Restrictions;
import org.navalplanner.business.common.daos.GenericDAOHibernate;
import org.navalplanner.business.planner.entities.DayAssigment;
import org.navalplanner.business.planner.entities.GenericDayAssigment;
import org.navalplanner.business.planner.entities.SpecificDayAssigment;
import org.navalplanner.business.planner.entities.DayAssignment;
import org.navalplanner.business.planner.entities.GenericDayAssignment;
import org.navalplanner.business.planner.entities.SpecificDayAssignment;
import org.navalplanner.business.planner.entities.TaskElement;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.context.annotation.Scope;
@ -25,31 +25,31 @@ public class TaskElementDAO extends GenericDAOHibernate<TaskElement, Long>
@Override
@Transactional
public void removeOrphanedDayAssignments() {
deleteAll(getOrphanedDayAssigments());
deleteAll(getOrphanedDayAssignments());
}
private void deleteAll(List<DayAssigment> orphaned) {
for (DayAssigment dayAssigment : orphaned) {
getSession().delete(dayAssigment);
private void deleteAll(List<DayAssignment> orphaned) {
for (DayAssignment dayAssignment : orphaned) {
getSession().delete(dayAssignment);
}
}
private List<DayAssigment> getOrphanedDayAssigments() {
List<DayAssigment> orphaned = new ArrayList<DayAssigment>();
private List<DayAssignment> getOrphanedDayAssignments() {
List<DayAssignment> orphaned = new ArrayList<DayAssignment>();
orphaned.addAll(findOrphanedGenericDayAssignments());
orphaned.addAll(findOrphanedSpecificDayAssignments());
return orphaned;
}
@SuppressWarnings("unchecked")
private List<GenericDayAssigment> findOrphanedGenericDayAssignments() {
return getSession().createCriteria(GenericDayAssigment.class).add(
private List<GenericDayAssignment> findOrphanedGenericDayAssignments() {
return getSession().createCriteria(GenericDayAssignment.class).add(
Restrictions.isNull("genericResourceAllocation")).list();
}
@SuppressWarnings("unchecked")
private List<SpecificDayAssigment> findOrphanedSpecificDayAssignments() {
return getSession().createCriteria(SpecificDayAssigment.class).add(
private List<SpecificDayAssignment> findOrphanedSpecificDayAssignments() {
return getSession().createCriteria(SpecificDayAssignment.class).add(
Restrictions.isNull("specificResourceAllocation")).list();
}
}

19
navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/AssigmentFunction.java
View file

@ -1,19 +0,0 @@
package org.navalplanner.business.planner.entities;
import org.navalplanner.business.common.BaseEntity;
/**
*
* @author Diego Pino García <dpino@igalia.com>
*
*/
public class AssigmentFunction extends BaseEntity {
public static AssigmentFunction create() {
return (AssigmentFunction) create(new AssigmentFunction());
}
public AssigmentFunction() {
}
}

19
navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/AssignmentFunction.java Normal file
View file

@ -0,0 +1,19 @@
package org.navalplanner.business.planner.entities;
import org.navalplanner.business.common.BaseEntity;
/**
*
* @author Diego Pino García <dpino@igalia.com>
*
*/
public class AssignmentFunction extends BaseEntity {
public static AssignmentFunction create() {
return (AssignmentFunction) create(new AssignmentFunction());
}
public AssignmentFunction() {
}
}

28
navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/DayAssigment.java → navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/DayAssignment.java
View file

@ -17,17 +17,17 @@ import org.joda.time.LocalDate;
import org.navalplanner.business.common.BaseEntity;
import org.navalplanner.business.resources.entities.Resource;
public abstract class DayAssigment extends BaseEntity {
public abstract class DayAssignment extends BaseEntity {
public static <T extends DayAssigment> Map<Resource, List<T>> byResourceAndOrdered(
Collection<T> assigments) {
public static <T extends DayAssignment> Map<Resource, List<T>> byResourceAndOrdered(
Collection<T> assignments) {
Map<Resource, List<T>> result = new HashMap<Resource, List<T>>();
for (T assigment : assigments) {
Resource resource = assigment.getResource();
for (T assignment : assignments) {
Resource resource = assignment.getResource();
if (!result.containsKey(resource)) {
result.put(resource, new ArrayList<T>());
}
result.get(resource).add(assigment);
result.get(resource).add(assignment);
}
for (Entry<Resource, List<T>> entry : result.entrySet()) {
Collections.sort(entry.getValue(), byDayComparator());
@ -35,7 +35,7 @@ public abstract class DayAssigment extends BaseEntity {
return result;
}
public static <T extends DayAssigment> Map<LocalDate, List<T>> byDay(
public static <T extends DayAssignment> Map<LocalDate, List<T>> byDay(
Collection<T> assignments) {
Map<LocalDate, List<T>> result = new HashMap<LocalDate, List<T>>();
for (T t : assignments) {
@ -57,11 +57,11 @@ public abstract class DayAssigment extends BaseEntity {
@NotNull
private Resource resource;
protected DayAssigment() {
protected DayAssignment() {
}
protected DayAssigment(LocalDate day, int hours, Resource resource) {
protected DayAssignment(LocalDate day, int hours, Resource resource) {
Validate.notNull(day);
Validate.isTrue(hours >= 0);
Validate.notNull(resource);
@ -87,17 +87,17 @@ public abstract class DayAssigment extends BaseEntity {
return ToStringBuilder.reflectionToString(this);
}
public static Comparator<DayAssigment> byDayComparator() {
return new Comparator<DayAssigment>() {
public static Comparator<DayAssignment> byDayComparator() {
return new Comparator<DayAssignment>() {
@Override
public int compare(DayAssigment assigment1, DayAssigment assigment2) {
return assigment1.getDay().compareTo(assigment2.getDay());
public int compare(DayAssignment assignment1, DayAssignment assignment2) {
return assignment1.getDay().compareTo(assignment2.getDay());
}
};
}
public static <T extends DayAssigment> List<T> orderedByDay(
public static <T extends DayAssignment> List<T> orderedByDay(
Collection<T> dayAssignments) {
List<T> result = new ArrayList<T>(dayAssignments);
Collections.sort(result, byDayComparator());

10
navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/GenericDayAssigment.java → navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/GenericDayAssignment.java
View file

@ -8,24 +8,24 @@ import org.navalplanner.business.resources.entities.Resource;
* @author Diego Pino García <dpino@igalia.com>
*
*/
public class GenericDayAssigment extends DayAssigment {
public class GenericDayAssignment extends DayAssignment {
private GenericResourceAllocation genericResourceAllocation;
public static GenericDayAssigment create(LocalDate day, int hours,
public static GenericDayAssignment create(LocalDate day, int hours,
Resource resource) {
return (GenericDayAssigment) create(new GenericDayAssigment(day, hours,
return (GenericDayAssignment) create(new GenericDayAssignment(day, hours,
resource));
}
private GenericDayAssigment(LocalDate day, int hours, Resource resource) {
private GenericDayAssignment(LocalDate day, int hours, Resource resource) {
super(day, hours, resource);
}
/**
* Constructor for hibernate. DO NOT USE!
*/
public GenericDayAssigment() {
public GenericDayAssignment() {
}

46
navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/GenericResourceAllocation.java
View file

@ -22,9 +22,9 @@ public class GenericResourceAllocation extends ResourceAllocation {
private Set<Criterion> criterions;
private Set<GenericDayAssigment> genericDayAssigments = new HashSet<GenericDayAssigment>();
private Set<GenericDayAssignment> genericDayAssignments = new HashSet<GenericDayAssignment>();
private Map<Resource, List<GenericDayAssigment>> orderedDayAssignmentsByResource = null;
private Map<Resource, List<GenericDayAssignment>> orderedDayAssignmentsByResource = null;
public static GenericResourceAllocation create() {
return (GenericResourceAllocation) create(new GenericResourceAllocation());
@ -54,22 +54,22 @@ public class GenericResourceAllocation extends ResourceAllocation {
this.criterions = task.getCriterions();
}
public Set<GenericDayAssigment> getGenericDayAssigments() {
return Collections.unmodifiableSet(genericDayAssigments);
public Set<GenericDayAssignment> getGenericDayAssignments() {
return Collections.unmodifiableSet(genericDayAssignments);
}
public List<GenericDayAssigment> getOrderedAssigmentsFor(Resource resource) {
List<GenericDayAssigment> list = getOrderedAssignmentsFor().get(
public List<GenericDayAssignment> getOrderedAssignmentsFor(Resource resource) {
List<GenericDayAssignment> list = getOrderedAssignmentsFor().get(
resource);
if (list == null)
return Collections.emptyList();
return Collections.unmodifiableList(list);
}
private Map<Resource, List<GenericDayAssigment>> getOrderedAssignmentsFor() {
private Map<Resource, List<GenericDayAssignment>> getOrderedAssignmentsFor() {
if (orderedDayAssignmentsByResource == null) {
orderedDayAssignmentsByResource = DayAssigment
.byResourceAndOrdered(genericDayAssigments);
orderedDayAssignmentsByResource = DayAssignment
.byResourceAndOrdered(genericDayAssignments);
}
return orderedDayAssignmentsByResource;
}
@ -83,7 +83,7 @@ public class GenericResourceAllocation extends ResourceAllocation {
}
private class GenericAllocation extends
AssignmentsAllocation<GenericDayAssigment> {
AssignmentsAllocation<GenericDayAssignment> {
private final List<Resource> resources;
@ -106,19 +106,19 @@ public class GenericResourceAllocation extends ResourceAllocation {
}
@Override
protected List<GenericDayAssigment> distributeForDay(LocalDate day,
protected List<GenericDayAssignment> distributeForDay(LocalDate day,
int totalHours) {
List<GenericDayAssigment> result = new ArrayList<GenericDayAssigment>();
List<GenericDayAssignment> result = new ArrayList<GenericDayAssignment>();
List<Share> shares = currentSharesFor(day);
ShareDivision currentDivision = ShareDivision.create(shares);
ShareDivision newDivison = currentDivision.plus(totalHours);
int[] differences = currentDivision.to(newDivison);
for (int i = 0; i < differences.length; i++) {
assert differences[i] >= 0;
GenericDayAssigment dayAssigment = GenericDayAssigment.create(
GenericDayAssignment dayAssignment = GenericDayAssignment.create(
day, differences[i], resources
.get(i));
result.add(dayAssigment);
result.add(dayAssignment);
}
return result;
}
@ -139,8 +139,8 @@ public class GenericResourceAllocation extends ResourceAllocation {
}
@Override
protected void resetAssignmentsTo(List<GenericDayAssigment> assignments) {
setAssigments(assignments);
protected void resetAssignmentsTo(List<GenericDayAssignment> assignments) {
setAssignments(assignments);
}
}
@ -149,22 +149,22 @@ public class GenericResourceAllocation extends ResourceAllocation {
return new GenericAllocation(new ArrayList<Resource>(resources));
}
private void setAssigments(List<GenericDayAssigment> assignmentsCreated) {
this.genericDayAssigments = new HashSet<GenericDayAssigment>(
private void setAssignments(List<GenericDayAssignment> assignmentsCreated) {
this.genericDayAssignments = new HashSet<GenericDayAssignment>(
assignmentsCreated);
setParentFor(assignmentsCreated);
clearFieldsCalculatedFromAssignments();
}
private void setParentFor(List<GenericDayAssigment> assignmentsCreated) {
for (GenericDayAssigment genericDayAssigment : assignmentsCreated) {
genericDayAssigment.setGenericResourceAllocation(this);
private void setParentFor(List<GenericDayAssignment> assignmentsCreated) {
for (GenericDayAssignment genericDayAssignment : assignmentsCreated) {
genericDayAssignment.setGenericResourceAllocation(this);
}
}
@Override
public List<? extends DayAssigment> getAssignments() {
return DayAssigment.orderedByDay(genericDayAssigments);
public List<? extends DayAssignment> getAssignments() {
return DayAssignment.orderedByDay(genericDayAssignments);
}
}

24
navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/ResourceAllocation.java
View file

@ -22,7 +22,7 @@ public abstract class ResourceAllocation extends BaseEntity {
@NotNull
private Task task;
private AssigmentFunction assigmentFunction;
private AssignmentFunction assignmentFunction;
@NotNull
private ResourcesPerDay resourcesPerDay;
@ -43,10 +43,10 @@ public abstract class ResourceAllocation extends BaseEntity {
this(task, null);
}
public ResourceAllocation(Task task, AssigmentFunction assignmentFunction) {
public ResourceAllocation(Task task, AssignmentFunction assignmentFunction) {
Validate.notNull(task);
this.task = task;
assigmentFunction = assignmentFunction;
assignmentFunction = assignmentFunction;
}
protected ResourceAllocation(ResourcesPerDay resourcesPerDay, Task task) {
@ -59,22 +59,22 @@ public abstract class ResourceAllocation extends BaseEntity {
return task;
}
protected abstract class AssignmentsAllocation<T extends DayAssigment>
protected abstract class AssignmentsAllocation<T extends DayAssignment>
implements IAllocatable {
@Override
public final void allocate(ResourcesPerDay resourcesPerDay) {
Task task = getTask();
LocalDate startInclusive = new LocalDate(task.getStartDate());
List<T> assigmentsCreated = new ArrayList<T>();
List<T> assignmentsCreated = new ArrayList<T>();
for (int i = 0; i < getDaysElapsedAt(task); i++) {
LocalDate day = startInclusive.plusDays(i);
int totalForDay = calculateTotalToDistribute(day,
resourcesPerDay);
assigmentsCreated.addAll(distributeForDay(day, totalForDay));
assignmentsCreated.addAll(distributeForDay(day, totalForDay));
}
setResourcesPerDay(resourcesPerDay);
resetAssignmentsTo(assigmentsCreated);
resetAssignmentsTo(assignmentsCreated);
}
protected abstract void resetAssignmentsTo(List<T> assignments);
@ -111,19 +111,19 @@ public abstract class ResourceAllocation extends BaseEntity {
}
public AssigmentFunction getAssigmentFunction() {
return assigmentFunction;
public AssignmentFunction getAssignmentFunction() {
return assignmentFunction;
}
public int getAssignedHours() {
int total = 0;
for (DayAssigment dayAssigment : getAssignments()) {
total += dayAssigment.getHours();
for (DayAssignment dayAssignment : getAssignments()) {
total += dayAssignment.getHours();
}
return total;
}
public abstract List<? extends DayAssigment> getAssignments();
public abstract List<? extends DayAssignment> getAssignments();
public ResourcesPerDay getResourcesPerDay() {

10
navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/SpecificDayAssigment.java → navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/SpecificDayAssignment.java
View file

@ -9,24 +9,24 @@ import org.navalplanner.business.resources.entities.Resource;
* @author Diego Pino García <dpino@igalia.com>
*
*/
public class SpecificDayAssigment extends DayAssigment {
public class SpecificDayAssignment extends DayAssignment {
private SpecificResourceAllocation specificResourceAllocation;
public static SpecificDayAssigment create(LocalDate day, int hours,
public static SpecificDayAssignment create(LocalDate day, int hours,
Resource resource) {
return (SpecificDayAssigment) create(new SpecificDayAssigment(day,
return (SpecificDayAssignment) create(new SpecificDayAssignment(day,
hours, resource));
}
public SpecificDayAssigment(LocalDate day, int hours, Resource resource) {
public SpecificDayAssignment(LocalDate day, int hours, Resource resource) {
super(day, hours, resource);
}
/**
* Constructor for hibernate. DO NOT USE!
*/
public SpecificDayAssigment() {
public SpecificDayAssignment() {
}

26
navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/SpecificResourceAllocation.java
View file

@ -27,7 +27,7 @@ public class SpecificResourceAllocation extends ResourceAllocation implements
@NotNull
private Resource resource;
private Set<SpecificDayAssigment> specificDaysAssigment = new HashSet<SpecificDayAssigment>();
private Set<SpecificDayAssignment> specificDaysAssignment = new HashSet<SpecificDayAssignment>();
public static SpecificResourceAllocation createForTesting(
ResourcesPerDay resourcesPerDay, Task task) {
@ -60,20 +60,20 @@ public class SpecificResourceAllocation extends ResourceAllocation implements
}
@Override
public List<SpecificDayAssigment> getAssignments() {
return DayAssigment.orderedByDay(specificDaysAssigment);
public List<SpecificDayAssignment> getAssignments() {
return DayAssignment.orderedByDay(specificDaysAssignment);
}
private void setAssignments(List<SpecificDayAssigment> assignments) {
this.specificDaysAssigment = new HashSet<SpecificDayAssigment>(
private void setAssignments(List<SpecificDayAssignment> assignments) {
this.specificDaysAssignment = new HashSet<SpecificDayAssignment>(
assignments);
setParentFor(specificDaysAssigment);
setParentFor(specificDaysAssignment);
}
private void setParentFor(
Collection<? extends SpecificDayAssigment> assignments) {
for (SpecificDayAssigment specificDayAssigment : assignments) {
specificDayAssigment.setSpecificResourceAllocation(this);
Collection<? extends SpecificDayAssignment> assignments) {
for (SpecificDayAssignment specificDayAssignment : assignments) {
specificDayAssignment.setSpecificResourceAllocation(this);
}
}
@ -81,18 +81,18 @@ public class SpecificResourceAllocation extends ResourceAllocation implements
public void allocate(ResourcesPerDay resourcesPerDay) {
Validate.notNull(resourcesPerDay);
Validate.notNull(resource);
AssignmentsAllocation<SpecificDayAssigment> assignmentsAllocation = new AssignmentsAllocation<SpecificDayAssigment>() {
AssignmentsAllocation<SpecificDayAssignment> assignmentsAllocation = new AssignmentsAllocation<SpecificDayAssignment>() {
@Override
protected List<SpecificDayAssigment> distributeForDay(
protected List<SpecificDayAssignment> distributeForDay(
LocalDate day, int totalHours) {
return Arrays.asList(SpecificDayAssigment.create(day,
return Arrays.asList(SpecificDayAssignment.create(day,
totalHours, resource));
}
@Override
protected void resetAssignmentsTo(
List<SpecificDayAssigment> assignments) {
List<SpecificDayAssignment> assignments) {
setAssignments(assignments);
}
};

32
navalplanner-business/src/main/java/org/navalplanner/business/resources/entities/Resource.java
View file

@ -16,7 +16,7 @@ import org.apache.commons.lang.Validate;
import org.joda.time.LocalDate;
import org.navalplanner.business.calendars.entities.ResourceCalendar;
import org.navalplanner.business.common.BaseEntity;
import org.navalplanner.business.planner.entities.DayAssigment;
import org.navalplanner.business.planner.entities.DayAssignment;
// FIXME: Alternatively, Resource can be modeled with the style:
// Resource.getParent() & Resource.getChilds(). This way, Resource does not
@ -37,19 +37,19 @@ public abstract class Resource extends BaseEntity{
private Set<CriterionSatisfaction> criterionSatisfactions = new HashSet<CriterionSatisfaction>();
private Set<DayAssigment> dayAssigments = new HashSet<DayAssigment>();
private Set<DayAssignment> dayAssignments = new HashSet<DayAssignment>();
private Map<LocalDate, List<DayAssigment>> assigmentsByDayCached = null;
private Map<LocalDate, List<DayAssignment>> assignmentsByDayCached = null;
private void clearCachedData() {
assigmentsByDayCached = null;
assignmentsByDayCached = null;
}
private List<DayAssigment> getAssigmentsForDay(LocalDate date) {
if (assigmentsByDayCached == null) {
assigmentsByDayCached = DayAssigment.byDay(dayAssigments);
private List<DayAssignment> getAssignmentsForDay(LocalDate date) {
if (assignmentsByDayCached == null) {
assignmentsByDayCached = DayAssignment.byDay(dayAssignments);
}
List<DayAssigment> list = assigmentsByDayCached.get(date);
List<DayAssignment> list = assignmentsByDayCached.get(date);
if (list == null){
return Collections.emptyList();
}
@ -475,21 +475,21 @@ public abstract class Resource extends BaseEntity{
public int getAssignedHours(LocalDate localDate) {
int sum = 0;
for (DayAssigment dayAssigment : getAssigmentsForDay(localDate)) {
sum += dayAssigment.getHours();
for (DayAssignment dayAssignment : getAssignmentsForDay(localDate)) {
sum += dayAssignment.getHours();
}
return sum;
}
public void addNewAssigments(Collection<? extends DayAssigment> assigments) {
Validate.notNull(assigments);
Validate.noNullElements(assigments);
public void addNewAssignments(Collection<? extends DayAssignment> assignments) {
Validate.notNull(assignments);
Validate.noNullElements(assignments);
clearCachedData();
this.dayAssigments.addAll(assigments);
this.dayAssignments.addAll(assignments);
}
public List<DayAssigment> getAssigments() {
return new ArrayList<DayAssigment>(dayAssigments);
public List<DayAssignment> getAssignments() {
return new ArrayList<DayAssignment>(dayAssignments);
}
}

10
navalplanner-business/src/main/resources/org/navalplanner/business/advance/entities/Advance.hbm.xml
View file

@ -18,8 +18,8 @@
<property name="active" access="field"/>
</class>
<!-- AdvanceAssigment -->
<class name="AdvanceAssigment">
<!-- AdvanceAssignment -->
<class name="AdvanceAssignment">
<id name="id" type="long" access="property">
<generator class="hilo">
<param name="max_lo">100</param>
@ -31,7 +31,7 @@
<property name="maxValue" access="field" scale="2"/>
<property name="type" access="field">
<type name="org.hibernate.type.EnumType">
<param name="enumClass">org.navalplanner.business.advance.entities.AdvanceAssigment$Type</param>
<param name="enumClass">org.navalplanner.business.advance.entities.AdvanceAssignment$Type</param>
</type>
</property>
@ -44,7 +44,7 @@
inverse="true"
access="field"
sort="org.navalplanner.business.advance.entities.AdvanceMeasurementComparator">
<key column="ADVANCE_ASSIGMENT_ID" />
<key column="ADVANCE_ASSIGNMENT_ID" />
<one-to-many class="org.navalplanner.business.advance.entities.AdvanceMeasurement"></one-to-many>
</set>
</class>
@ -60,6 +60,6 @@
<property name="date" access="field" type="org.joda.time.contrib.hibernate.PersistentLocalDate" />
<property name="value" scale="2" access="field" />
<many-to-one name="advanceAssigment" class="AdvanceAssigment" column="ADVANCE_ASSIGMENT_ID" access="field" />
<many-to-one name="advanceAssignment" class="AdvanceAssignment" column="ADVANCE_ASSIGNMENT_ID" access="field" />
</class>
</hibernate-mapping>

4
navalplanner-business/src/main/resources/org/navalplanner/business/orders/entities/Orders.hbm.xml
View file

@ -40,9 +40,9 @@
<key column="ORDER_ELEMENT_ID" />
<one-to-many class="org.navalplanner.business.planner.entities.TaskElement"></one-to-many>
</set>
<set name="advanceAssigments" access="field" cascade="all,delete-orphan" inverse="true">
<set name="advanceAssignments" access="field" cascade="all,delete-orphan" inverse="true">
<key column="ORDER_ELEMENT_ID" />
<one-to-many class="org.navalplanner.business.advance.entities.AdvanceAssigment"></one-to-many>
<one-to-many class="org.navalplanner.business.advance.entities.AdvanceAssignment"></one-to-many>
</set>
<set name="labels" table="ORDER_ELEMENT_LABEL" access="field">

28
navalplanner-business/src/main/resources/org/navalplanner/business/planner/entities/ResourceAllocations.hbm.xml
View file

@ -16,7 +16,7 @@
<many-to-one class="Task" name="task" column="TASK" />
<many-to-one class="AssigmentFunction" name="assigmentFunction" column="ASSIGMENT_FUNCTION" not-null="false"/>
<many-to-one class="AssignmentFunction" name="assignmentFunction" column="ASSIGNMENT_FUNCTION" not-null="false"/>
<joined-subclass name="SpecificResourceAllocation" table="SPECIFIC_RESOURCE_ALLOCATION">
<key column="RESOURCE_ALLOCATION_ID" />
@ -24,9 +24,9 @@
<many-to-one name="resource"
class="org.navalplanner.business.resources.entities.Resource" />
<set name="specificDaysAssigment" cascade="all">
<set name="specificDaysAssignment" cascade="all">
<key column="SPECIFIC_RESOURCE_ALLOCATION_ID"/>
<one-to-many class="SpecificDayAssigment"/>
<one-to-many class="SpecificDayAssignment"/>
</set>
</joined-subclass>
@ -38,22 +38,22 @@
<many-to-many class="org.navalplanner.business.resources.entities.Criterion" column="criterion_id"/>
</set>
<set name="genericDayAssigments" cascade="all">
<set name="genericDayAssignments" cascade="all">
<key column="GENERIC_RESOURCE_ALLOCATION_ID"/>
<one-to-many class="GenericDayAssigment"/>
<one-to-many class="GenericDayAssignment"/>
</set>
</joined-subclass>
</class>
<!-- DayAssigment -->
<class name="DayAssigment" table="DAY_ASSIGMENT">
<!-- DayAssignment -->
<class name="DayAssignment" table="DAY_ASSIGNMENT">
<id name="id" type="long" access="property">
<generator class="hilo">
<param name="max_lo">100</param>
</generator>
</id>
<discriminator column="DAY_ASSIGMENT_TYPE" type="string"/>
<discriminator column="DAY_ASSIGNMENT_TYPE" type="string"/>
<version name="version" access="property" type="long" />
@ -65,21 +65,21 @@
column="RESOURCE_ID" not-null="true">
</many-to-one>
<!-- SpecificDayAssigment -->
<subclass name="SpecificDayAssigment" discriminator-value="SPECIFIC_DAY">
<!-- SpecificDayAssignment -->
<subclass name="SpecificDayAssignment" discriminator-value="SPECIFIC_DAY">
<many-to-one name="specificResourceAllocation"
class="SpecificResourceAllocation" column="SPECIFIC_RESOURCE_ALLOCATION_ID"/>
</subclass>
<!-- GenericDayAssigment -->
<subclass name="GenericDayAssigment" discriminator-value="GENERIC_DAY">
<!-- GenericDayAssignment -->
<subclass name="GenericDayAssignment" discriminator-value="GENERIC_DAY">
<many-to-one name="genericResourceAllocation"
class="GenericResourceAllocation" column="GENERIC_RESOURCE_ALLOCATION_ID" />
</subclass>
</class>
<!-- AssigmentFunction -->
<class name="AssigmentFunction" table="ASSIGMENT_FUNCTION">
<!-- AssignmentFunction -->
<class name="AssignmentFunction" table="ASSIGNMENT_FUNCTION">
<id name="id" type="long" access="property">
<generator class="hilo">
<param name="max_lo">100</param>

4
navalplanner-business/src/main/resources/org/navalplanner/business/resources/entities/Resources.hbm.xml
View file

@ -17,9 +17,9 @@
<one-to-many class="CriterionSatisfaction"/>
</set>
<set access="field" inverse="true" name="dayAssigments">
<set access="field" inverse="true" name="dayAssignments">
<key column="RESOURCE_ID" not-null="true"/>
<one-to-many class="org.navalplanner.business.planner.entities.DayAssigment"/>
<one-to-many class="org.navalplanner.business.planner.entities.DayAssignment"/>
</set>
<many-to-one name="calendar" access="field" cascade="all"

4
navalplanner-business/src/test/java/org/navalplanner/business/test/advance/entities/AdvanceAssigmentTest.java → navalplanner-business/src/test/java/org/navalplanner/business/test/advance/entities/AdvanceAssignmentTest.java
View file

@ -4,9 +4,9 @@ import static junit.framework.Assert.assertTrue;
import org.junit.Test;
public class AdvanceAssigmentTest {
public class AdvanceAssignmentTest {
@Test
public void testAdvanceAssigmentTest() {
public void testAdvanceAssignmentTest() {
assertTrue(true);
}

146
navalplanner-business/src/test/java/org/navalplanner/business/test/orders/entities/AddAdvanceAssigmentsToOrderElementTest.java → navalplanner-business/src/test/java/org/navalplanner/business/test/orders/entities/AddAdvanceAssignmentsToOrderElementTest.java
View file

@ -15,12 +15,12 @@ import org.hibernate.SessionFactory;
import org.joda.time.LocalDate;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.navalplanner.business.advance.daos.IAdvanceAssigmentDAO;
import org.navalplanner.business.advance.daos.IAdvanceAssignmentDAO;
import org.navalplanner.business.advance.daos.IAdvanceTypeDAO;
import org.navalplanner.business.advance.entities.AdvanceAssigment;
import org.navalplanner.business.advance.entities.AdvanceAssignment;
import org.navalplanner.business.advance.entities.AdvanceMeasurement;
import org.navalplanner.business.advance.entities.AdvanceType;
import org.navalplanner.business.advance.exceptions.DuplicateAdvanceAssigmentForOrderElementException;
import org.navalplanner.business.advance.exceptions.DuplicateAdvanceAssignmentForOrderElementException;
import org.navalplanner.business.advance.exceptions.DuplicateValueTrueReportGlobalAdvanceException;
import org.navalplanner.business.common.exceptions.InstanceNotFoundException;
import org.navalplanner.business.orders.daos.IOrderDAO;
@ -37,14 +37,14 @@ import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;
/**
* Tests for {@link AdvanceAssigment of OrderElement}. <br />
* Tests for {@link AdvanceAssignment of OrderElement}. <br />
* @author Susana Montes Pedreira <smontes@wirelessgalicia.com>
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { BUSINESS_SPRING_CONFIG_FILE,
BUSINESS_SPRING_CONFIG_TEST_FILE })
@Transactional
public class AddAdvanceAssigmentsToOrderElementTest {
public class AddAdvanceAssignmentsToOrderElementTest {
@Autowired
private SessionFactory sessionFactory;
@ -56,7 +56,7 @@ public class AddAdvanceAssigmentsToOrderElementTest {
private IOrderDAO orderDao;
@Autowired
private IAdvanceAssigmentDAO advanceAssigmentDao;
private IAdvanceAssignmentDAO advanceAssignmentDao;
@Autowired
private IAdvanceTypeDAO advanceTypeDao;
@ -98,36 +98,36 @@ public class AddAdvanceAssigmentsToOrderElementTest {
return advanceMeasurement;
}
private AdvanceAssigment createValidAdvanceAssigment(
private AdvanceAssignment createValidAdvanceAssignment(
boolean reportGlobalAdvance) {
AdvanceAssigment advanceAssigment = AdvanceAssigment.create(
AdvanceAssignment advanceAssignment = AdvanceAssignment.create(
reportGlobalAdvance,new BigDecimal(0));
advanceAssigment.setType(AdvanceAssigment.Type.DIRECT);
return advanceAssigment;
advanceAssignment.setType(AdvanceAssignment.Type.DIRECT);
return advanceAssignment;
}
@Test
public void savingTheOrderSavesAlsoTheAddedAssigments() throws Exception {
public void savingTheOrderSavesAlsoTheAddedAssignments() throws Exception {
Order order = createValidOrder();
OrderElement orderLine = createValidLeaf("OrderLineA", "1k1k1k1k");
AdvanceType advanceType = createAndSaveType("tipoA");
AdvanceAssigment advanceAssigment = createValidAdvanceAssigment(true);
assertTrue(orderLine.getAdvanceAssigments().isEmpty());
advanceAssigment.setAdvanceType(advanceType);
AdvanceAssignment advanceAssignment = createValidAdvanceAssignment(true);
assertTrue(orderLine.getAdvanceAssignments().isEmpty());
advanceAssignment.setAdvanceType(advanceType);
order.add(orderLine);
orderDao.save(order);
orderLine.addAdvanceAssigment(advanceAssigment);
orderLine.addAdvanceAssignment(advanceAssignment);
order.add(orderLine);
orderDao.save(order);
this.sessionFactory.getCurrentSession().flush();
assertFalse(orderLine.getAdvanceAssigments().isEmpty());
assertTrue(advanceAssigmentDao.exists(advanceAssigment.getId()));
assertFalse(orderLine.getAdvanceAssignments().isEmpty());
assertTrue(advanceAssignmentDao.exists(advanceAssignment.getId()));
}
@ -145,17 +145,17 @@ public class AddAdvanceAssigmentsToOrderElementTest {
AdvanceType advanceTypeA = createAndSaveType("tipoA");
AdvanceType advanceTypeB = createAndSaveType("tipoB");
AdvanceAssigment advanceAssigmentA = createValidAdvanceAssigment(true);
advanceAssigmentA.setAdvanceType(advanceTypeA);
AdvanceAssignment advanceAssignmentA = createValidAdvanceAssignment(true);
advanceAssignmentA.setAdvanceType(advanceTypeA);
order.add(orderLine);
orderDao.save(order);
orderLine.addAdvanceAssigment(advanceAssigmentA);
orderLine.addAdvanceAssignment(advanceAssignmentA);
AdvanceAssigment advanceAssigmentB = createValidAdvanceAssigment(false);
advanceAssigmentB.setAdvanceType(advanceTypeB);
orderLine.addAdvanceAssigment(advanceAssigmentB);
AdvanceAssignment advanceAssignmentB = createValidAdvanceAssignment(false);
advanceAssignmentB.setAdvanceType(advanceTypeB);
orderLine.addAdvanceAssignment(advanceAssignmentB);
}
@Test
@ -165,18 +165,18 @@ public class AddAdvanceAssigmentsToOrderElementTest {
AdvanceType advanceTypeA = createAndSaveType("tipoA");
AdvanceAssigment advanceAssigmentA = createValidAdvanceAssigment(true);
advanceAssigmentA.setAdvanceType(advanceTypeA);
AdvanceAssignment advanceAssignmentA = createValidAdvanceAssignment(true);
advanceAssignmentA.setAdvanceType(advanceTypeA);
orderLine.addAdvanceAssigment(advanceAssigmentA);
orderLine.addAdvanceAssignment(advanceAssignmentA);
AdvanceAssigment advanceAssigmentB = createValidAdvanceAssigment(false);
advanceAssigmentB.setAdvanceType(advanceTypeA);
AdvanceAssignment advanceAssignmentB = createValidAdvanceAssignment(false);
advanceAssignmentB.setAdvanceType(advanceTypeA);
try {
orderLine.addAdvanceAssigment(advanceAssigmentB);
orderLine.addAdvanceAssignment(advanceAssignmentB);
fail("It should throw an exception");
} catch (DuplicateAdvanceAssigmentForOrderElementException e) {
} catch (DuplicateAdvanceAssignmentForOrderElementException e) {
// Ok
}
}
@ -188,16 +188,16 @@ public class AddAdvanceAssigmentsToOrderElementTest {
AdvanceType advanceTypeA = createAndSaveType("tipoA");
AdvanceType advanceTypeB = createAndSaveType("tipoB");
AdvanceAssigment advanceAssigmentA = createValidAdvanceAssigment(true);
advanceAssigmentA.setAdvanceType(advanceTypeA);
AdvanceAssignment advanceAssignmentA = createValidAdvanceAssignment(true);
advanceAssignmentA.setAdvanceType(advanceTypeA);
orderLine.addAdvanceAssigment(advanceAssigmentA);
orderLine.addAdvanceAssignment(advanceAssignmentA);
AdvanceAssigment advanceAssigmentB = createValidAdvanceAssigment(true);
advanceAssigmentB.setAdvanceType(advanceTypeB);
AdvanceAssignment advanceAssignmentB = createValidAdvanceAssignment(true);
advanceAssignmentB.setAdvanceType(advanceTypeB);
try {
orderLine.addAdvanceAssigment(advanceAssigmentB);
orderLine.addAdvanceAssignment(advanceAssignmentB);
fail("It should throw an exception ");
} catch (DuplicateValueTrueReportGlobalAdvanceException e) {
// Ok
@ -217,16 +217,16 @@ public class AddAdvanceAssigmentsToOrderElementTest {
AdvanceType advanceTypeA = createAndSaveType("tipoA");
AdvanceType advanceTypeB = createAndSaveType("tipoB");
AdvanceAssigment advanceAssigmentA = createValidAdvanceAssigment(true);
advanceAssigmentA.setAdvanceType(advanceTypeA);
advanceAssigmentA.getAdvanceMeasurements().add(advanceMeasurement);
AdvanceAssigment advanceAssigmentB = createValidAdvanceAssigment(false);
advanceAssigmentB.setAdvanceType(advanceTypeB);
advanceAssigmentB.getAdvanceMeasurements().add(advanceMeasurement);
AdvanceAssignment advanceAssignmentA = createValidAdvanceAssignment(true);
advanceAssignmentA.setAdvanceType(advanceTypeA);
advanceAssignmentA.getAdvanceMeasurements().add(advanceMeasurement);
AdvanceAssignment advanceAssignmentB = createValidAdvanceAssignment(false);
advanceAssignmentB.setAdvanceType(advanceTypeB);
advanceAssignmentB.getAdvanceMeasurements().add(advanceMeasurement);
container.addAdvanceAssigment(advanceAssigmentA);
son.addAdvanceAssigment(advanceAssigmentB);
container.addAdvanceAssignment(advanceAssignmentA);
son.addAdvanceAssignment(advanceAssignmentB);
}
@Test
@ -238,16 +238,16 @@ public class AddAdvanceAssigmentsToOrderElementTest {
container.add(createValidLeaf("bla", "979"));
AdvanceType advanceTypeA = createAndSaveType("tipoA");
AdvanceAssigment advanceAssigmentA = createValidAdvanceAssigment(true);
advanceAssigmentA.setAdvanceType(advanceTypeA);
AdvanceAssignment advanceAssignmentA = createValidAdvanceAssignment(true);
advanceAssignmentA.setAdvanceType(advanceTypeA);
container.addAdvanceAssigment(advanceAssigmentA);
container.addAdvanceAssignment(advanceAssignmentA);
assertThat(container.getAdvanceAssigments().size(), equalTo(1));
assertThat(container.getAdvanceAssignments().size(), equalTo(1));
}
@Test
public void cannotAddDuplicatedAssigmentToSon() throws Exception {
public void cannotAddDuplicatedAssignmentToSon() throws Exception {
final OrderLineGroup father = OrderLineGroup.create();
father.setName("bla");
father.setCode("000000000");
@ -255,18 +255,18 @@ public class AddAdvanceAssigmentsToOrderElementTest {
AdvanceType advanceTypeA = createAndSaveType("tipoA");
AdvanceAssigment advanceAssigmentA = createValidAdvanceAssigment(true);
advanceAssigmentA.setAdvanceType(advanceTypeA);
AdvanceAssigment anotherAssigmentWithSameType = createValidAdvanceAssigment(false);
anotherAssigmentWithSameType.setAdvanceType(advanceTypeA);
AdvanceAssignment advanceAssignmentA = createValidAdvanceAssignment(true);
advanceAssignmentA.setAdvanceType(advanceTypeA);
AdvanceAssignment anotherAssignmentWithSameType = createValidAdvanceAssignment(false);
anotherAssignmentWithSameType.setAdvanceType(advanceTypeA);
father.addAdvanceAssigment(advanceAssigmentA);
father.addAdvanceAssignment(advanceAssignmentA);
try {
OrderElement child = (OrderElement) father.getChildren().get(0);
child.addAdvanceAssigment(anotherAssigmentWithSameType);
child.addAdvanceAssignment(anotherAssignmentWithSameType);
fail("It should throw an exception ");
} catch (DuplicateAdvanceAssigmentForOrderElementException e) {
} catch (DuplicateAdvanceAssignmentForOrderElementException e) {
// Ok
}
}
@ -286,25 +286,25 @@ public class AddAdvanceAssigmentsToOrderElementTest {
AdvanceMeasurement advanceMeasurement = createValidAdvanceMeasurement();
AdvanceType advanceTypeA = createAndSaveType("tipoA");
AdvanceAssigment advanceAssigmentA = createValidAdvanceAssigment(true);
advanceAssigmentA.setAdvanceType(advanceTypeA);
advanceAssigmentA.getAdvanceMeasurements().add(advanceMeasurement);
AdvanceAssigment advanceAssigmentB = createValidAdvanceAssigment(false);
advanceAssigmentB.setAdvanceType(advanceTypeA);
advanceAssigmentB.getAdvanceMeasurements().add(advanceMeasurement);
AdvanceAssignment advanceAssignmentA = createValidAdvanceAssignment(true);
advanceAssignmentA.setAdvanceType(advanceTypeA);
advanceAssignmentA.getAdvanceMeasurements().add(advanceMeasurement);
AdvanceAssignment advanceAssignmentB = createValidAdvanceAssignment(false);
advanceAssignmentB.setAdvanceType(advanceTypeA);
advanceAssignmentB.getAdvanceMeasurements().add(advanceMeasurement);
grandSon.addAdvanceAssigment(advanceAssigmentA);
grandSon.addAdvanceAssignment(advanceAssignmentA);
try {
parent.addAdvanceAssigment(advanceAssigmentB);
parent.addAdvanceAssignment(advanceAssignmentB);
fail("It should throw an exception ");
} catch (DuplicateAdvanceAssigmentForOrderElementException e) {
} catch (DuplicateAdvanceAssignmentForOrderElementException e) {
// Ok
}
}
@Test(expected = DuplicateAdvanceAssigmentForOrderElementException.class)
public void addingAnotherAdvanceAssigmentWithAnEquivalentTypeButDifferentInstance()
@Test(expected = DuplicateAdvanceAssignmentForOrderElementException.class)
public void addingAnotherAdvanceAssignmentWithAnEquivalentTypeButDifferentInstance()
throws Exception {
final Order order = createValidOrder();
OrderLine line = createValidLeaf("GranSon", "75757");
@ -317,13 +317,13 @@ public class AddAdvanceAssigmentsToOrderElementTest {
AdvanceType typeReloaded = reloadType(type);
AdvanceAssigment assigment = createValidAdvanceAssigment(false);
assigment.setAdvanceType(type);
AdvanceAssigment assigmentWithSameType = createValidAdvanceAssigment(false);
assigmentWithSameType.setAdvanceType(typeReloaded);
AdvanceAssignment assignment = createValidAdvanceAssignment(false);
assignment.setAdvanceType(type);
AdvanceAssignment assignmentWithSameType = createValidAdvanceAssignment(false);
assignmentWithSameType.setAdvanceType(typeReloaded);
line.addAdvanceAssigment(assigment);
line.addAdvanceAssigment(assigmentWithSameType);
line.addAdvanceAssignment(assignment);
line.addAdvanceAssignment(assignmentWithSameType);
}
private AdvanceType reloadType(AdvanceType type) {

136
navalplanner-business/src/test/java/org/navalplanner/business/test/orders/entities/OrderElementTest.java
View file

@ -21,12 +21,12 @@ import org.junit.Test;
import org.junit.runner.RunWith;
import org.navalplanner.business.IDataBootstrap;
import org.navalplanner.business.advance.bootstrap.PredefinedAdvancedTypes;
import org.navalplanner.business.advance.entities.AdvanceAssigment;
import org.navalplanner.business.advance.entities.AdvanceAssignment;
import org.navalplanner.business.advance.entities.AdvanceMeasurement;
import org.navalplanner.business.advance.entities.AdvanceMeasurementComparator;
import org.navalplanner.business.advance.entities.AdvanceType;
import org.navalplanner.business.advance.entities.AdvanceAssigment.Type;
import org.navalplanner.business.advance.exceptions.DuplicateAdvanceAssigmentForOrderElementException;
import org.navalplanner.business.advance.entities.AdvanceAssignment.Type;
import org.navalplanner.business.advance.exceptions.DuplicateAdvanceAssignmentForOrderElementException;
import org.navalplanner.business.advance.exceptions.DuplicateValueTrueReportGlobalAdvanceException;
import org.navalplanner.business.orders.entities.OrderElement;
import org.navalplanner.business.orders.entities.OrderLine;
@ -84,31 +84,31 @@ public class OrderElementTest {
return orderLineGroup;
}
private AdvanceAssigment givenAdvanceAssigement(BigDecimal maxValue,
private AdvanceAssignment givenAdvanceAssigement(BigDecimal maxValue,
AdvanceType advanceType) {
AdvanceAssigment advanceAssigment = AdvanceAssigment.create();
advanceAssigment.setMaxValue(maxValue);
advanceAssigment.setAdvanceType(advanceType);
advanceAssigment.setReportGlobalAdvance(false);
advanceAssigment.setType(Type.DIRECT);
AdvanceAssignment advanceAssignment = AdvanceAssignment.create();
advanceAssignment.setMaxValue(maxValue);
advanceAssignment.setAdvanceType(advanceType);
advanceAssignment.setReportGlobalAdvance(false);
advanceAssignment.setType(Type.DIRECT);
return advanceAssigment;
return advanceAssignment;
}
private void addAvanceAssigmentWithMeasurement(OrderElement orderElement,
private void addAvanceAssignmentWithMeasurement(OrderElement orderElement,
AdvanceType advanceType, BigDecimal maxValue,
BigDecimal currentValue)
throws DuplicateValueTrueReportGlobalAdvanceException,
DuplicateAdvanceAssigmentForOrderElementException {
DuplicateAdvanceAssignmentForOrderElementException {
AdvanceMeasurement advanceMeasurement = AdvanceMeasurement.create();
advanceMeasurement.setDate(new LocalDate());
advanceMeasurement.setValue(currentValue);
AdvanceAssigment advanceAssigment = givenAdvanceAssigement(maxValue,
AdvanceAssignment advanceAssignment = givenAdvanceAssigement(maxValue,
advanceType);
advanceAssigment.getAdvanceMeasurements().add(advanceMeasurement);
advanceAssignment.getAdvanceMeasurements().add(advanceMeasurement);
orderElement.addAdvanceAssigment(advanceAssigment);
orderElement.addAdvanceAssignment(advanceAssignment);
}
private AdvanceType givenAdvanceType(String name) {
@ -127,30 +127,30 @@ public class OrderElementTest {
}
@Test
public void checkAdvancePercentageOrderLineWithAdvanceAssigmentWithoutMesaurement()
public void checkAdvancePercentageOrderLineWithAdvanceAssignmentWithoutMesaurement()
throws DuplicateValueTrueReportGlobalAdvanceException,
DuplicateAdvanceAssigmentForOrderElementException {
DuplicateAdvanceAssignmentForOrderElementException {
OrderLine orderLine = givenOrderLine("name", "code", 1000);
AdvanceAssigment advanceAssigment = givenAdvanceAssigement(
AdvanceAssignment advanceAssignment = givenAdvanceAssigement(
new BigDecimal(5000), PredefinedAdvancedTypes.UNITS.getType());
orderLine.addAdvanceAssigment(advanceAssigment);
orderLine.addAdvanceAssignment(advanceAssignment);
assertThat(orderLine.getAdvancePercentage(), equalTo(new BigDecimal(0)
.setScale(2)));
}
@Test
public void checkAdvancePercentageOrderLineWithTwoAssigments()
public void checkAdvancePercentageOrderLineWithTwoAssignments()
throws DuplicateValueTrueReportGlobalAdvanceException,
DuplicateAdvanceAssigmentForOrderElementException {
DuplicateAdvanceAssignmentForOrderElementException {
OrderLine orderLine = givenOrderLine("name", "code", 1000);
addAvanceAssigmentWithMeasurement(orderLine, givenAdvanceType("test1"),
addAvanceAssignmentWithMeasurement(orderLine, givenAdvanceType("test1"),
new BigDecimal(2000), new BigDecimal(200));
addAvanceAssigmentWithMeasurement(orderLine, givenAdvanceType("test2"),
addAvanceAssignmentWithMeasurement(orderLine, givenAdvanceType("test2"),
new BigDecimal(1000), new BigDecimal(600));
assertThat(orderLine.getAdvancePercentage(), equalTo(new BigDecimal(35)
@ -158,18 +158,18 @@ public class OrderElementTest {
}
@Test
public void checkAdvancePercentageOrderLineWithThreeAssigments()
public void checkAdvancePercentageOrderLineWithThreeAssignments()
throws DuplicateValueTrueReportGlobalAdvanceException,
DuplicateAdvanceAssigmentForOrderElementException {
DuplicateAdvanceAssignmentForOrderElementException {
OrderLine orderLine = givenOrderLine("name", "code", 1000);
addAvanceAssigmentWithMeasurement(orderLine, givenAdvanceType("test1"),
addAvanceAssignmentWithMeasurement(orderLine, givenAdvanceType("test1"),
new BigDecimal(2000), new BigDecimal(200));
addAvanceAssigmentWithMeasurement(orderLine, givenAdvanceType("test2"),
addAvanceAssignmentWithMeasurement(orderLine, givenAdvanceType("test2"),
new BigDecimal(1000), new BigDecimal(600));
addAvanceAssigmentWithMeasurement(orderLine, givenAdvanceType("test3"),
addAvanceAssignmentWithMeasurement(orderLine, givenAdvanceType("test3"),
new BigDecimal(4000), new BigDecimal(800));
assertThat(orderLine.getAdvancePercentage(), equalTo(new BigDecimal(30)
@ -179,15 +179,15 @@ public class OrderElementTest {
@Test
public void checkAdvancePercentageOrderGroupLine()
throws DuplicateValueTrueReportGlobalAdvanceException,
DuplicateAdvanceAssigmentForOrderElementException {
DuplicateAdvanceAssignmentForOrderElementException {
OrderElement orderElement = givenOrderLineGroupWithTwoOrderLines(1000,
2000);
List<OrderElement> children = orderElement.getChildren();
addAvanceAssigmentWithMeasurement(children.get(0),
addAvanceAssignmentWithMeasurement(children.get(0),
PredefinedAdvancedTypes.UNITS.getType(), new BigDecimal(1000),
new BigDecimal(400));
addAvanceAssigmentWithMeasurement(children.get(1),
addAvanceAssignmentWithMeasurement(children.get(1),
PredefinedAdvancedTypes.UNITS.getType(), new BigDecimal(2000),
new BigDecimal(200));
@ -196,21 +196,21 @@ public class OrderElementTest {
}
@Test
public void checkAdvancePercentageOrderGroupLineWithAssigments()
public void checkAdvancePercentageOrderGroupLineWithAssignments()
throws DuplicateValueTrueReportGlobalAdvanceException,
DuplicateAdvanceAssigmentForOrderElementException {
DuplicateAdvanceAssignmentForOrderElementException {
OrderElement orderElement = givenOrderLineGroupWithTwoOrderLines(1000,
2000);
List<OrderElement> children = orderElement.getChildren();
addAvanceAssigmentWithMeasurement(children.get(0),
addAvanceAssignmentWithMeasurement(children.get(0),
PredefinedAdvancedTypes.UNITS.getType(), new BigDecimal(1000),
new BigDecimal(400));
addAvanceAssigmentWithMeasurement(children.get(1),
addAvanceAssignmentWithMeasurement(children.get(1),
PredefinedAdvancedTypes.UNITS.getType(), new BigDecimal(2000),
new BigDecimal(200));
addAvanceAssigmentWithMeasurement(orderElement,
addAvanceAssignmentWithMeasurement(orderElement,
PredefinedAdvancedTypes.PERCENTAGE.getType(), new BigDecimal(
100), new BigDecimal(10));
@ -221,7 +221,7 @@ public class OrderElementTest {
@Test
public void checkAdvanceMeasurementMerge()
throws DuplicateValueTrueReportGlobalAdvanceException,
DuplicateAdvanceAssigmentForOrderElementException {
DuplicateAdvanceAssignmentForOrderElementException {
OrderElement orderElement = givenOrderLineGroupWithTwoOrderLines(1000,
2000);
@ -235,23 +235,23 @@ public class OrderElementTest {
AdvanceType advanceType = PredefinedAdvancedTypes.UNITS.getType();
addAvanceAssigmentWithMeasurements(children.get(0),
addAvanceAssignmentWithMeasurements(children.get(0),
advanceType,
new BigDecimal(1000), one, new BigDecimal(200), three,
new BigDecimal(400), five, new BigDecimal(500));
addAvanceAssigmentWithMeasurements(children.get(1),
addAvanceAssignmentWithMeasurements(children.get(1),
advanceType,
new BigDecimal(1000), two, new BigDecimal(100), three,
new BigDecimal(350), four, new BigDecimal(400));
Set<AdvanceAssigment> advanceAssigments = orderElement.getAdvanceAssigments();
assertThat(advanceAssigments.size(), equalTo(1));
AdvanceAssigment advanceAssigment = advanceAssigments.iterator().next();
assertThat(advanceAssigment.getMaxValue(),
Set<AdvanceAssignment> advanceAssignments = orderElement.getAdvanceAssignments();
assertThat(advanceAssignments.size(), equalTo(1));
AdvanceAssignment advanceAssignment = advanceAssignments.iterator().next();
assertThat(advanceAssignment.getMaxValue(),
equalTo(new BigDecimal(2000)));
SortedSet<AdvanceMeasurement> advanceMeasurements = advanceAssigment
SortedSet<AdvanceMeasurement> advanceMeasurements = advanceAssignment
.getAdvanceMeasurements();
assertThat(advanceMeasurements.size(), equalTo(5));
@ -283,38 +283,38 @@ public class OrderElementTest {
}
private void addAvanceAssigmentWithMeasurements(OrderElement orderElement,
private void addAvanceAssignmentWithMeasurements(OrderElement orderElement,
AdvanceType advanceType, BigDecimal maxValue, LocalDate date1,
BigDecimal value1, LocalDate date2, BigDecimal value2,
LocalDate five,
BigDecimal date3)
throws DuplicateValueTrueReportGlobalAdvanceException,
DuplicateAdvanceAssigmentForOrderElementException {
AdvanceAssigment advanceAssigment = givenAdvanceAssigement(maxValue,
DuplicateAdvanceAssignmentForOrderElementException {
AdvanceAssignment advanceAssignment = givenAdvanceAssigement(maxValue,
advanceType);
AdvanceMeasurement advanceMeasurement1 = AdvanceMeasurement.create();
advanceMeasurement1.setDate(date1);
advanceMeasurement1.setValue(value1);
advanceAssigment.getAdvanceMeasurements().add(advanceMeasurement1);
advanceAssignment.getAdvanceMeasurements().add(advanceMeasurement1);
AdvanceMeasurement advanceMeasurement2 = AdvanceMeasurement.create();
advanceMeasurement2.setDate(date2);
advanceMeasurement2.setValue(value2);
advanceAssigment.getAdvanceMeasurements().add(advanceMeasurement2);
advanceAssignment.getAdvanceMeasurements().add(advanceMeasurement2);
AdvanceMeasurement advanceMeasurement3 = AdvanceMeasurement.create();
advanceMeasurement3.setDate(five);
advanceMeasurement3.setValue(date3);
advanceAssigment.getAdvanceMeasurements().add(advanceMeasurement3);
advanceAssignment.getAdvanceMeasurements().add(advanceMeasurement3);
orderElement.addAdvanceAssigment(advanceAssigment);
orderElement.addAdvanceAssignment(advanceAssignment);
}
@Test
public void checkGetAdvanceAssigmentsIdempotenet()
public void checkGetAdvanceAssignmentsIdempotenet()
throws DuplicateValueTrueReportGlobalAdvanceException,
DuplicateAdvanceAssigmentForOrderElementException {
DuplicateAdvanceAssignmentForOrderElementException {
OrderElement orderElement = givenOrderLineGroupWithTwoOrderLines(1000,
2000);
@ -322,32 +322,32 @@ public class OrderElementTest {
AdvanceType advanceType = PredefinedAdvancedTypes.UNITS.getType();
addAvanceAssigmentWithMeasurement(children.get(0), advanceType,
addAvanceAssignmentWithMeasurement(children.get(0), advanceType,
new BigDecimal(1000), new BigDecimal(200));
addAvanceAssigmentWithMeasurement(children.get(1), advanceType,
addAvanceAssignmentWithMeasurement(children.get(1), advanceType,
new BigDecimal(2000), new BigDecimal(400));
Set<AdvanceAssigment> advanceAssigments = orderElement
.getAdvanceAssigments();
assertThat(advanceAssigments.size(), equalTo(1));
AdvanceAssigment advanceAssigment = advanceAssigments.iterator().next();
assertThat(advanceAssigment.getMaxValue(),
Set<AdvanceAssignment> advanceAssignments = orderElement
.getAdvanceAssignments();
assertThat(advanceAssignments.size(), equalTo(1));
AdvanceAssignment advanceAssignment = advanceAssignments.iterator().next();
assertThat(advanceAssignment.getMaxValue(),
equalTo(new BigDecimal(3000)));
assertThat(advanceAssigment.getAdvanceMeasurements().size(), equalTo(1));
assertThat(advanceAssigment.getAdvanceMeasurements().iterator().next()
assertThat(advanceAssignment.getAdvanceMeasurements().size(), equalTo(1));
assertThat(advanceAssignment.getAdvanceMeasurements().iterator().next()
.getValue(), equalTo(new BigDecimal(600)));
advanceAssigments = orderElement.getAdvanceAssigments();
assertThat(advanceAssigments.size(), equalTo(1));
advanceAssigment = advanceAssigments.iterator().next();
assertThat(advanceAssigment.getMaxValue(),
advanceAssignments = orderElement.getAdvanceAssignments();
assertThat(advanceAssignments.size(), equalTo(1));
advanceAssignment = advanceAssignments.iterator().next();
assertThat(advanceAssignment.getMaxValue(),
equalTo(new BigDecimal(3000)));
assertThat(advanceAssigment.getAdvanceMeasurements().size(), equalTo(1));
assertThat(advanceAssigment.getAdvanceMeasurements().iterator().next()
assertThat(advanceAssignment.getAdvanceMeasurements().size(), equalTo(1));
assertThat(advanceAssignment.getAdvanceMeasurements().iterator().next()
.getValue(), equalTo(new BigDecimal(600)));
}

72
navalplanner-business/src/test/java/org/navalplanner/business/test/planner/daos/AssigmentFunctionDAOTest.java
View file

@ -1,72 +0,0 @@
package org.navalplanner.business.test.planner.daos;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.navalplanner.business.BusinessGlobalNames.BUSINESS_SPRING_CONFIG_FILE;
import static org.navalplanner.business.test.BusinessGlobalNames.BUSINESS_SPRING_CONFIG_TEST_FILE;
import java.util.List;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.navalplanner.business.common.exceptions.InstanceNotFoundException;
import org.navalplanner.business.planner.daos.IAssigmentFunctionDAO;
import org.navalplanner.business.planner.entities.AssigmentFunction;
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;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { BUSINESS_SPRING_CONFIG_FILE,
BUSINESS_SPRING_CONFIG_TEST_FILE })
/*
* @author Diego Pino García <dpino@igalia.com>
*/
@Transactional
public class AssigmentFunctionDAOTest {
@Autowired
private IAssigmentFunctionDAO assigmentFunctionDAO;
@Test
public void testInSpringContainer() {
assertTrue(assigmentFunctionDAO != null);
}
private AssigmentFunction createValidAssigmentFunction() {
return AssigmentFunction.create();
}
@Test
public void testSaveAssigmentFunction() {
AssigmentFunction assigmentFunction = createValidAssigmentFunction();
assigmentFunctionDAO.save(assigmentFunction);
assertTrue(assigmentFunctionDAO.exists(assigmentFunction.getId()));
}
@Test
public void testRemoveAssigmentFunction()
throws InstanceNotFoundException {
AssigmentFunction assigmentFunction = createValidAssigmentFunction();
assigmentFunctionDAO.save(assigmentFunction);
assigmentFunctionDAO.remove(assigmentFunction.getId());
assertFalse(assigmentFunctionDAO.exists(assigmentFunction.getId()));
}
@Test
public void testListAssigmentFunction() {
int previous = assigmentFunctionDAO.list(AssigmentFunction.class).size();
AssigmentFunction assigmentFunction1 = createValidAssigmentFunction();
assigmentFunctionDAO.save(assigmentFunction1);
AssigmentFunction assigmentFunction2 = createValidAssigmentFunction();
assigmentFunctionDAO.save(assigmentFunction1);
assigmentFunctionDAO.save(assigmentFunction2);
List<AssigmentFunction> list = assigmentFunctionDAO
.list(AssigmentFunction.class);
assertEquals(previous + 2, list.size());
}
}

72
navalplanner-business/src/test/java/org/navalplanner/business/test/planner/daos/AssignmentFunctionDAOTest.java Normal file
View file

@ -0,0 +1,72 @@
package org.navalplanner.business.test.planner.daos;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.navalplanner.business.BusinessGlobalNames.BUSINESS_SPRING_CONFIG_FILE;
import static org.navalplanner.business.test.BusinessGlobalNames.BUSINESS_SPRING_CONFIG_TEST_FILE;
import java.util.List;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.navalplanner.business.common.exceptions.InstanceNotFoundException;
import org.navalplanner.business.planner.daos.IAssignmentFunctionDAO;
import org.navalplanner.business.planner.entities.AssignmentFunction;
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;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { BUSINESS_SPRING_CONFIG_FILE,
BUSINESS_SPRING_CONFIG_TEST_FILE })
/*
* @author Diego Pino García <dpino@igalia.com>
*/
@Transactional
public class AssignmentFunctionDAOTest {
@Autowired
private IAssignmentFunctionDAO assignmentFunctionDAO;
@Test
public void testInSpringContainer() {
assertTrue(assignmentFunctionDAO != null);
}
private AssignmentFunction createValidAssignmentFunction() {
return AssignmentFunction.create();
}
@Test
public void testSaveAssignmentFunction() {
AssignmentFunction assignmentFunction = createValidAssignmentFunction();
assignmentFunctionDAO.save(assignmentFunction);
assertTrue(assignmentFunctionDAO.exists(assignmentFunction.getId()));
}
@Test
public void testRemoveAssignmentFunction()
throws InstanceNotFoundException {
AssignmentFunction assignmentFunction = createValidAssignmentFunction();
assignmentFunctionDAO.save(assignmentFunction);
assignmentFunctionDAO.remove(assignmentFunction.getId());
assertFalse(assignmentFunctionDAO.exists(assignmentFunction.getId()));
}
@Test
public void testListAssignmentFunction() {
int previous = assignmentFunctionDAO.list(AssignmentFunction.class).size();
AssignmentFunction assignmentFunction1 = createValidAssignmentFunction();
assignmentFunctionDAO.save(assignmentFunction1);
AssignmentFunction assignmentFunction2 = createValidAssignmentFunction();
assignmentFunctionDAO.save(assignmentFunction1);
assignmentFunctionDAO.save(assignmentFunction2);
List<AssignmentFunction> list = assignmentFunctionDAO
.list(AssignmentFunction.class);
assertEquals(previous + 2, list.size());
}
}

90
navalplanner-business/src/test/java/org/navalplanner/business/test/planner/daos/DayAssigmentDAOTest.java → navalplanner-business/src/test/java/org/navalplanner/business/test/planner/daos/DayAssignmentDAOTest.java
View file

@ -12,10 +12,10 @@ import org.joda.time.LocalDate;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.navalplanner.business.common.exceptions.InstanceNotFoundException;
import org.navalplanner.business.planner.daos.IDayAssigmentDAO;
import org.navalplanner.business.planner.entities.DayAssigment;
import org.navalplanner.business.planner.entities.GenericDayAssigment;
import org.navalplanner.business.planner.entities.SpecificDayAssigment;
import org.navalplanner.business.planner.daos.IDayAssignmentDAO;
import org.navalplanner.business.planner.entities.DayAssignment;
import org.navalplanner.business.planner.entities.GenericDayAssignment;
import org.navalplanner.business.planner.entities.SpecificDayAssignment;
import org.navalplanner.business.resources.daos.IResourceDAO;
import org.navalplanner.business.resources.entities.Resource;
import org.navalplanner.business.resources.entities.Worker;
@ -32,16 +32,16 @@ import org.springframework.transaction.annotation.Transactional;
* @author Diego Pino García <dpino@igalia.com>
*/
@Transactional
public class DayAssigmentDAOTest {
public class DayAssignmentDAOTest {
@Autowired
private IDayAssigmentDAO dayAssigmentDAO;
private IDayAssignmentDAO dayAssignmentDAO;
@Autowired
private IResourceDAO resourceDAO;
private SpecificDayAssigment createValidSpecificDayAssigment() {
return SpecificDayAssigment.create(new LocalDate(2009, 1, 2), 8,
private SpecificDayAssignment createValidSpecificDayAssignment() {
return SpecificDayAssignment.create(new LocalDate(2009, 1, 2), 8,
createValidResource());
}
@ -51,86 +51,86 @@ public class DayAssigmentDAOTest {
return worker;
}
private GenericDayAssigment createValidGenericDayAssigment() {
return GenericDayAssigment.create(new LocalDate(2009, 1, 2), 8,
private GenericDayAssignment createValidGenericDayAssignment() {
return GenericDayAssignment.create(new LocalDate(2009, 1, 2), 8,
createValidResource());
}
@Test
public void testInSpringContainer() {
assertTrue(dayAssigmentDAO != null);
assertTrue(dayAssignmentDAO != null);
}
@Test
public void testSaveSpecificResourceAllocation() {
SpecificDayAssigment dayAssigment = createValidSpecificDayAssigment();
dayAssigmentDAO.save(dayAssigment);
assertTrue(dayAssigmentDAO.exists(dayAssigment.getId()));
SpecificDayAssignment dayAssignment = createValidSpecificDayAssignment();
dayAssignmentDAO.save(dayAssignment);
assertTrue(dayAssignmentDAO.exists(dayAssignment.getId()));
}
@Test
public void testSaveGenericResourceAllocation() {
GenericDayAssigment dayAssigment = createValidGenericDayAssigment();
dayAssigmentDAO.save(dayAssigment);
assertTrue(dayAssigmentDAO.exists(dayAssigment.getId()));
GenericDayAssignment dayAssignment = createValidGenericDayAssignment();
dayAssignmentDAO.save(dayAssignment);
assertTrue(dayAssignmentDAO.exists(dayAssignment.getId()));
}
@Test(expected = DataIntegrityViolationException.class)
public void theRelatedResourceMustExistInOrderToSave() {
Worker transientWorker = Worker.create("first", "surname",
"1221332132A");
SpecificDayAssigment dayAssigment = SpecificDayAssigment.create(
SpecificDayAssignment dayAssignment = SpecificDayAssignment.create(
new LocalDate(2009, 1, 2), 8, transientWorker);
dayAssigmentDAO.save(dayAssigment);
dayAssignmentDAO.save(dayAssignment);
}
@Test
public void testRemoveSpecificResourceAllocation()
throws InstanceNotFoundException {
SpecificDayAssigment dayAssigment = createValidSpecificDayAssigment();
dayAssigmentDAO.save(dayAssigment);
dayAssigmentDAO.remove(dayAssigment.getId());
assertFalse(dayAssigmentDAO.exists(dayAssigment.getId()));
SpecificDayAssignment dayAssignment = createValidSpecificDayAssignment();
dayAssignmentDAO.save(dayAssignment);
dayAssignmentDAO.remove(dayAssignment.getId());
assertFalse(dayAssignmentDAO.exists(dayAssignment.getId()));
}
@Test
public void testRemoveGenericResourceAllocation()
throws InstanceNotFoundException {
GenericDayAssigment dayAssigment = createValidGenericDayAssigment();
dayAssigmentDAO.save(dayAssigment);
dayAssigmentDAO.remove(dayAssigment.getId());
assertFalse(dayAssigmentDAO.exists(dayAssigment.getId()));
GenericDayAssignment dayAssignment = createValidGenericDayAssignment();
dayAssignmentDAO.save(dayAssignment);
dayAssignmentDAO.remove(dayAssignment.getId());
assertFalse(dayAssignmentDAO.exists(dayAssignment.getId()));
}
@Test
public void testListSpecificDayAssigment() {
int previous = dayAssigmentDAO.list(DayAssigment.class)
public void testListSpecificDayAssignment() {
int previous = dayAssignmentDAO.list(DayAssignment.class)
.size();
SpecificDayAssigment dayAssigment1 = createValidSpecificDayAssigment();
dayAssigmentDAO.save(dayAssigment1);
SpecificDayAssigment dayAssigment2 = createValidSpecificDayAssigment();
dayAssigmentDAO.save(dayAssigment1);
dayAssigmentDAO.save(dayAssigment2);
SpecificDayAssignment dayAssignment1 = createValidSpecificDayAssignment();
dayAssignmentDAO.save(dayAssignment1);
SpecificDayAssignment dayAssignment2 = createValidSpecificDayAssignment();
dayAssignmentDAO.save(dayAssignment1);
dayAssignmentDAO.save(dayAssignment2);
List<SpecificDayAssigment> list = dayAssigmentDAO
.list(SpecificDayAssigment.class);
List<SpecificDayAssignment> list = dayAssignmentDAO
.list(SpecificDayAssignment.class);
assertEquals(previous + 2, list.size());
}
@Test
public void testListGenericDayAssigment() {
int previous = dayAssigmentDAO.list(DayAssigment.class)
public void testListGenericDayAssignment() {
int previous = dayAssignmentDAO.list(DayAssignment.class)
.size();
GenericDayAssigment dayAssigment1 = createValidGenericDayAssigment();
dayAssigmentDAO.save(dayAssigment1);
GenericDayAssigment dayAssigment2 = createValidGenericDayAssigment();
dayAssigmentDAO.save(dayAssigment1);
dayAssigmentDAO.save(dayAssigment2);
GenericDayAssignment dayAssignment1 = createValidGenericDayAssignment();
dayAssignmentDAO.save(dayAssignment1);
GenericDayAssignment dayAssignment2 = createValidGenericDayAssignment();
dayAssignmentDAO.save(dayAssignment1);
dayAssignmentDAO.save(dayAssignment2);
List<GenericDayAssigment> list = dayAssigmentDAO
.list(GenericDayAssigment.class);
List<GenericDayAssignment> list = dayAssignmentDAO
.list(GenericDayAssignment.class);
assertEquals(previous + 2, list.size());
}
}

64
navalplanner-business/src/test/java/org/navalplanner/business/test/planner/entities/DayAssigmentMatchers.java → navalplanner-business/src/test/java/org/navalplanner/business/test/planner/entities/DayAssignmentMatchers.java
View file

@ -10,35 +10,35 @@ import org.hamcrest.Matcher;
import org.joda.time.LocalDate;
import org.junit.matchers.CombinableMatcher;
import org.junit.matchers.JUnitMatchers;
import org.navalplanner.business.planner.entities.DayAssigment;
import org.navalplanner.business.planner.entities.GenericDayAssigment;
import org.navalplanner.business.planner.entities.DayAssignment;
import org.navalplanner.business.planner.entities.GenericDayAssignment;
import org.navalplanner.business.planner.entities.ResourceAllocation;
import org.navalplanner.business.planner.entities.SpecificDayAssigment;
import org.navalplanner.business.planner.entities.SpecificDayAssignment;
/**
* Some {@link Matcher} that work against dayAssigments
* Some {@link Matcher} that work against dayAssignments
* @author Óscar González Fernández <ogonzalez@igalia.com>
*/
public class DayAssigmentMatchers {
public class DayAssignmentMatchers {
public static abstract class ListDayAssigmentsMatcher extends
BaseMatcher<List<? extends DayAssigment>> {
public static abstract class ListDayAssignmentsMatcher extends
BaseMatcher<List<? extends DayAssignment>> {
@Override
final public boolean matches(Object value) {
if (value instanceof List) {
List<DayAssigment> dayAssigments = new ArrayList<DayAssigment>(
(List<DayAssigment>) value);
return matches(dayAssigments);
List<DayAssignment> dayAssignments = new ArrayList<DayAssignment>(
(List<DayAssignment>) value);
return matches(dayAssignments);
}
return false;
}
protected abstract boolean matches(List<DayAssigment> assignments);
protected abstract boolean matches(List<DayAssignment> assignments);
}
public static final class FromMatcher extends ListDayAssigmentsMatcher {
public static final class FromMatcher extends ListDayAssignmentsMatcher {
private final LocalDate start;
private FromMatcher(LocalDate start) {
@ -51,31 +51,31 @@ public class DayAssigmentMatchers {
+ start);
}
public CombinableMatcher<List<? extends DayAssigment>> consecutiveDays(
public CombinableMatcher<List<? extends DayAssignment>> consecutiveDays(
int days) {
return JUnitMatchers.both(this).and(
DayAssigmentMatchers.consecutiveDays(days));
DayAssignmentMatchers.consecutiveDays(days));
}
@Override
protected boolean matches(List<DayAssigment> assignments) {
protected boolean matches(List<DayAssignment> assignments) {
return !assignments.isEmpty()
&& assignments.get(0).getDay().equals(start);
}
}
public static final Matcher<List<? extends DayAssigment>> haveHours(
public static final Matcher<List<? extends DayAssignment>> haveHours(
final int... hours) {
return new BaseMatcher<List<? extends DayAssigment>>() {
return new BaseMatcher<List<? extends DayAssignment>>() {
@Override
public boolean matches(Object value) {
if (value instanceof List) {
List<? extends DayAssigment> assigments = (List<? extends GenericDayAssigment>) value;
if (assigments.size() != hours.length)
List<? extends DayAssignment> assignments = (List<? extends GenericDayAssignment>) value;
if (assignments.size() != hours.length)
return false;
for (int i = 0; i < hours.length; i++) {
if (hours[i] != assigments.get(i).getHours()) {
if (hours[i] != assignments.get(i).getHours()) {
return false;
}
}
@ -92,11 +92,11 @@ public class DayAssigmentMatchers {
};
}
public static ListDayAssigmentsMatcher consecutiveDays(final int days) {
return new ListDayAssigmentsMatcher() {
public static ListDayAssignmentsMatcher consecutiveDays(final int days) {
return new ListDayAssignmentsMatcher() {
@Override
public boolean matches(List<DayAssigment> assignments) {
public boolean matches(List<DayAssignment> assignments) {
if (assignments.size() != days) {
return false;
}
@ -104,7 +104,7 @@ public class DayAssigmentMatchers {
return true;
}
LocalDate current = assignments.get(0).getDay();
for (DayAssigment d : assignments) {
for (DayAssignment d : assignments) {
if (!d.getDay().equals(current)) {
return false;
}
@ -125,21 +125,21 @@ public class DayAssigmentMatchers {
return new FromMatcher(start);
}
public static ListDayAssigmentsMatcher haveResourceAllocation(
public static ListDayAssignmentsMatcher haveResourceAllocation(
final ResourceAllocation allocation) {
return new ListDayAssigmentsMatcher() {
return new ListDayAssignmentsMatcher() {
@Override
protected boolean matches(List<DayAssigment> assignments) {
for (DayAssigment dayAssigment : assignments) {
if (dayAssigment instanceof GenericDayAssigment) {
GenericDayAssigment generic = (GenericDayAssigment) dayAssigment;
protected boolean matches(List<DayAssignment> assignments) {
for (DayAssignment dayAssignment : assignments) {
if (dayAssignment instanceof GenericDayAssignment) {
GenericDayAssignment generic = (GenericDayAssignment) dayAssignment;
if (!allocation.equals(generic
.getGenericResourceAllocation())) {
return false;
}
} else if (dayAssigment instanceof SpecificDayAssigment) {
SpecificDayAssigment specific = (SpecificDayAssigment) dayAssigment;
} else if (dayAssignment instanceof SpecificDayAssignment) {
SpecificDayAssignment specific = (SpecificDayAssignment) dayAssignment;
if (!allocation.equals(specific
.getSpecificResourceAllocation())) {
return false;

56
navalplanner-business/src/test/java/org/navalplanner/business/test/planner/entities/GenericResourceAllocationTest.java
View file

@ -8,9 +8,9 @@ import static org.hamcrest.CoreMatchers.equalTo;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.navalplanner.business.test.planner.entities.DayAssigmentMatchers.from;
import static org.navalplanner.business.test.planner.entities.DayAssigmentMatchers.haveHours;
import static org.navalplanner.business.test.planner.entities.DayAssigmentMatchers.haveResourceAllocation;
import static org.navalplanner.business.test.planner.entities.DayAssignmentMatchers.from;
import static org.navalplanner.business.test.planner.entities.DayAssignmentMatchers.haveHours;
import static org.navalplanner.business.test.planner.entities.DayAssignmentMatchers.haveResourceAllocation;
import java.util.ArrayList;
import java.util.Arrays;
@ -25,7 +25,7 @@ import org.joda.time.Period;
import org.junit.Test;
import org.navalplanner.business.calendars.entities.BaseCalendar;
import org.navalplanner.business.calendars.entities.SameWorkHoursEveryDay;
import org.navalplanner.business.planner.entities.GenericDayAssigment;
import org.navalplanner.business.planner.entities.GenericDayAssignment;
import org.navalplanner.business.planner.entities.GenericResourceAllocation;
import org.navalplanner.business.planner.entities.ResourcesPerDay;
import org.navalplanner.business.planner.entities.Task;
@ -149,10 +149,10 @@ public class GenericResourceAllocationTest {
public void getOrderedAssignmentsReturnsEmptyListIfNotExistsWorker() {
givenWorkersWithoutLoadAndWithoutCalendar();
givenGenericResourceAllocation();
List<GenericDayAssigment> assigments = genericResourceAllocation
.getOrderedAssigmentsFor(worker1);
assertNotNull(assigments);
assertTrue(assigments.isEmpty());
List<GenericDayAssignment> assignments = genericResourceAllocation
.getOrderedAssignmentsFor(worker1);
assertNotNull(assignments);
assertTrue(assignments.isEmpty());
}
@Test
@ -165,7 +165,7 @@ public class GenericResourceAllocationTest {
genericResourceAllocation.forResources(Arrays.asList(worker1))
.allocate(ResourcesPerDay.amount(1));
List<GenericDayAssigment> assignments = (List<GenericDayAssigment>) genericResourceAllocation
List<GenericDayAssignment> assignments = (List<GenericDayAssignment>) genericResourceAllocation
.getAssignments();
assertThat(assignments,
haveResourceAllocation(genericResourceAllocation));
@ -184,9 +184,9 @@ public class GenericResourceAllocationTest {
genericResourceAllocation.forResources(Arrays.asList(worker1))
.allocate(ResourcesPerDay.amount(1));
List<GenericDayAssigment> orderedAssigmentsFor = genericResourceAllocation
.getOrderedAssigmentsFor(worker1);
assertThat(orderedAssigmentsFor, from(start).consecutiveDays(
List<GenericDayAssignment> orderedAssignmentsFor = genericResourceAllocation
.getOrderedAssignmentsFor(worker1);
assertThat(orderedAssignmentsFor, from(start).consecutiveDays(
TASK_DURATION_DAYS));
}
@ -218,9 +218,9 @@ public class GenericResourceAllocationTest {
genericResourceAllocation.forResources(Arrays.asList(worker1))
.allocate(ResourcesPerDay.amount(2));
List<GenericDayAssigment> orderedAssigmentsFor = genericResourceAllocation
.getOrderedAssigmentsFor(worker1);
assertThat(orderedAssigmentsFor.get(0).getHours(),
List<GenericDayAssignment> orderedAssignmentsFor = genericResourceAllocation
.getOrderedAssignmentsFor(worker1);
assertThat(orderedAssignmentsFor.get(0).getHours(),
equalTo(standardHoursPerDay * 2));
}
@ -238,8 +238,8 @@ public class GenericResourceAllocationTest {
genericResourceAllocation.forResources(Arrays.asList(worker1))
.allocate(ResourcesPerDay.amount(1));
List<GenericDayAssigment> assigmments = genericResourceAllocation
.getOrderedAssigmentsFor(worker1);
List<GenericDayAssignment> assigmments = genericResourceAllocation
.getOrderedAssignmentsFor(worker1);
assertThat(assigmments, haveHours(halfWorkingDay));
}
@ -258,8 +258,8 @@ public class GenericResourceAllocationTest {
genericResourceAllocation.forResources(Arrays.asList(worker1))
.allocate(ResourcesPerDay.amount(1));
List<GenericDayAssigment> assigmments = genericResourceAllocation
.getOrderedAssigmentsFor(worker1);
List<GenericDayAssignment> assigmments = genericResourceAllocation
.getOrderedAssignmentsFor(worker1);
assertThat(assigmments.get(0).getHours(), equalTo(defaultWorkableHours));
}
@ -276,15 +276,15 @@ public class GenericResourceAllocationTest {
genericResourceAllocation.forResources(workers).allocate(
ResourcesPerDay.amount(1));
List<GenericDayAssigment> assigmentsWorker1 = genericResourceAllocation
.getOrderedAssigmentsFor(worker1);
assertThat(assigmentsWorker1, haveHours(3, 3, 3, 3));
List<GenericDayAssigment> assigmentsWorker2 = genericResourceAllocation
.getOrderedAssigmentsFor(worker2);
assertThat(assigmentsWorker2, haveHours(0, 0, 0, 0));
List<GenericDayAssigment> assigmentsWorker3 = genericResourceAllocation
.getOrderedAssigmentsFor(worker3);
assertThat(assigmentsWorker3, haveHours(5, 5, 5, 5));
List<GenericDayAssignment> assignmentsWorker1 = genericResourceAllocation
.getOrderedAssignmentsFor(worker1);
assertThat(assignmentsWorker1, haveHours(3, 3, 3, 3));
List<GenericDayAssignment> assignmentsWorker2 = genericResourceAllocation
.getOrderedAssignmentsFor(worker2);
assertThat(assignmentsWorker2, haveHours(0, 0, 0, 0));
List<GenericDayAssignment> assignmentsWorker3 = genericResourceAllocation
.getOrderedAssignmentsFor(worker3);
assertThat(assignmentsWorker3, haveHours(5, 5, 5, 5));
}
private static Interval toInterval(LocalDate start, Period period) {

8
navalplanner-business/src/test/java/org/navalplanner/business/test/planner/entities/SpecificResourceAllocationTest.java
View file

@ -5,8 +5,8 @@ import static org.easymock.EasyMock.isA;
import static org.easymock.classextension.EasyMock.createNiceMock;
import static org.easymock.classextension.EasyMock.replay;
import static org.junit.Assert.assertThat;
import static org.navalplanner.business.test.planner.entities.DayAssigmentMatchers.consecutiveDays;
import static org.navalplanner.business.test.planner.entities.DayAssigmentMatchers.from;
import static org.navalplanner.business.test.planner.entities.DayAssignmentMatchers.consecutiveDays;
import static org.navalplanner.business.test.planner.entities.DayAssignmentMatchers.from;
import org.joda.time.LocalDate;
import org.junit.Test;
@ -76,7 +76,7 @@ public class SpecificResourceAllocationTest {
givenSpecificResourceAllocation(new LocalDate(2000, 2, 4), 2);
specificResourceAllocation.allocate(ResourcesPerDay.amount(1));
assertThat(specificResourceAllocation.getAssignments(),
DayAssigmentMatchers
DayAssignmentMatchers
.haveResourceAllocation(specificResourceAllocation));
}
@ -95,7 +95,7 @@ public class SpecificResourceAllocationTest {
givenSpecificResourceAllocation(start, 2);
specificResourceAllocation.allocate(ResourcesPerDay.amount(1));
assertThat(specificResourceAllocation.getAssignments(),
DayAssigmentMatchers.haveHours(8, 8));
DayAssignmentMatchers.haveHours(8, 8));
}
}

66
navalplanner-business/src/test/java/org/navalplanner/business/test/resources/entities/ResourceTest.java
View file

@ -17,8 +17,8 @@ import java.util.List;
import org.joda.time.Days;
import org.joda.time.LocalDate;
import org.junit.Test;
import org.navalplanner.business.planner.entities.DayAssigment;
import org.navalplanner.business.planner.entities.SpecificDayAssigment;
import org.navalplanner.business.planner.entities.DayAssignment;
import org.navalplanner.business.planner.entities.SpecificDayAssignment;
import org.navalplanner.business.resources.entities.Criterion;
import org.navalplanner.business.resources.entities.CriterionSatisfaction;
import org.navalplanner.business.resources.entities.CriterionTypeBase;
@ -398,73 +398,73 @@ public class ResourceTest {
}
private Worker worker;
private List<DayAssigment> assigments;
private List<DayAssignment> assignments;
@Test(expected = IllegalArgumentException.class)
public void addNewAssigmentsMustReceiveNotNullArgument() {
public void addNewAssignmentsMustReceiveNotNullArgument() {
givenWorker();
worker.addNewAssigments(null);
worker.addNewAssignments(null);
}
@Test(expected = IllegalArgumentException.class)
public void mustHaveNoNullElements() {
givenWorker();
List<DayAssigment> list = new ArrayList<DayAssigment>();
List<DayAssignment> list = new ArrayList<DayAssignment>();
list.add(null);
worker.addNewAssigments(list);
worker.addNewAssignments(list);
}
@Test
public void newAssigmentsImportsTheAssigments() {
public void newAssignmentsImportsTheAssignments() {
givenWorker();
LocalDate today = new LocalDate();
LocalDate tomorrow = today.plus(Days.days(1));
SpecificDayAssigment specificDayAssigment = new SpecificDayAssigment(
SpecificDayAssignment specificDayAssignment = new SpecificDayAssignment(
today, 10, worker);
SpecificDayAssigment another = new SpecificDayAssigment(tomorrow, 10,
SpecificDayAssignment another = new SpecificDayAssignment(tomorrow, 10,
worker);
givenWorkerWithAssigments(specificDayAssigment, another);
givenWorkerWithAssignments(specificDayAssignment, another);
assertTrue(worker.getAssigments().containsAll(assigments));
assertTrue(worker.getAssigments().size() == assigments.size());
assertTrue(worker.getAssignments().containsAll(assignments));
assertTrue(worker.getAssignments().size() == assignments.size());
}
@Test
public void addingAdditionalAssigmentsKeepOld() {
public void addingAdditionalAssignmentsKeepOld() {
givenWorker();
LocalDate today = new LocalDate();
LocalDate tomorrow = today.plus(Days.days(1));
SpecificDayAssigment specificDayAssigment = new SpecificDayAssigment(
SpecificDayAssignment specificDayAssignment = new SpecificDayAssignment(
today, 10, worker);
SpecificDayAssigment another = new SpecificDayAssigment(tomorrow, 10,
SpecificDayAssignment another = new SpecificDayAssignment(tomorrow, 10,
worker);
givenWorkerWithAssigments(specificDayAssigment, another);
givenWorkerWithAssignments(specificDayAssignment, another);
DayAssigment other = new SpecificDayAssigment(today, 3, worker);
worker.addNewAssigments(Arrays.asList(other));
assertTrue(worker.getAssigments().size() == assigments.size() + 1);
DayAssignment other = new SpecificDayAssignment(today, 3, worker);
worker.addNewAssignments(Arrays.asList(other));
assertTrue(worker.getAssignments().size() == assignments.size() + 1);
}
@Test
public void workerWithoutAssigmentsGivesNoAssignedHours() {
public void workerWithoutAssignmentsGivesNoAssignedHours() {
givenWorker();
LocalDate today = new LocalDate();
assertThat(worker.getAssignedHours(today), equalTo(0));
}
@Test
public void workerWithAssigmentsGivesTheSumOfAssignedHoursForThatDay() {
public void workerWithAssignmentsGivesTheSumOfAssignedHoursForThatDay() {
givenWorker();
LocalDate today = new LocalDate();
SpecificDayAssigment specificDayAssigment = new SpecificDayAssigment(
SpecificDayAssignment specificDayAssignment = new SpecificDayAssignment(
today, 10, worker);
SpecificDayAssigment another = new SpecificDayAssigment(today, 3,
SpecificDayAssignment another = new SpecificDayAssignment(today, 3,
worker);
SpecificDayAssigment atAnotherDay = new SpecificDayAssigment(today
SpecificDayAssignment atAnotherDay = new SpecificDayAssignment(today
.plusDays(1), 1,
worker);
givenWorkerWithAssigments(specificDayAssigment, another, atAnotherDay);
givenWorkerWithAssignments(specificDayAssignment, another, atAnotherDay);
assertThat(worker.getAssignedHours(today), equalTo(13));
}
@ -473,20 +473,20 @@ public class ResourceTest {
public void afterAddingAnotherDontReturnTheOldResult() {
givenWorker();
LocalDate today = new LocalDate();
SpecificDayAssigment specificDayAssigment = new SpecificDayAssigment(
SpecificDayAssignment specificDayAssignment = new SpecificDayAssignment(
today, 10, worker);
givenWorkerWithAssigments(specificDayAssigment);
givenWorkerWithAssignments(specificDayAssignment);
worker.getAssignedHours(today);
SpecificDayAssigment another = new SpecificDayAssigment(today, 3,
SpecificDayAssignment another = new SpecificDayAssignment(today, 3,
worker);
worker.addNewAssigments(Arrays.asList(another));
worker.addNewAssignments(Arrays.asList(another));
assertThat(worker.getAssignedHours(today), equalTo(13));
}
private void givenWorkerWithAssigments(DayAssigment... assigments) {
this.assigments = Arrays.asList(assigments);
worker.addNewAssigments(this.assigments);
private void givenWorkerWithAssignments(DayAssignment... assignments) {
this.assignments = Arrays.asList(assignments);
worker.addNewAssignments(this.assignments);
}
private void givenWorker() {

18
navalplanner-webapp/src/main/java/org/navalplanner/web/orders/IManageOrderElementAdvancesModel.java
View file

@ -4,10 +4,10 @@ import java.math.BigDecimal;
import java.util.Date;
import java.util.List;
import org.navalplanner.business.advance.entities.AdvanceAssigment;
import org.navalplanner.business.advance.entities.AdvanceAssignment;
import org.navalplanner.business.advance.entities.AdvanceMeasurement;
import org.navalplanner.business.advance.entities.AdvanceType;
import org.navalplanner.business.advance.exceptions.DuplicateAdvanceAssigmentForOrderElementException;
import org.navalplanner.business.advance.exceptions.DuplicateAdvanceAssignmentForOrderElementException;
import org.navalplanner.business.advance.exceptions.DuplicateValueTrueReportGlobalAdvanceException;
import org.navalplanner.business.common.exceptions.InstanceNotFoundException;
import org.navalplanner.business.orders.entities.OrderElement;
@ -17,19 +17,19 @@ import org.navalplanner.business.orders.entities.OrderElement;
*/
public interface IManageOrderElementAdvancesModel {
public void prepareEditAdvanceMeasurements(AdvanceAssigment advanceAssigment);
public void prepareEditAdvanceMeasurements(AdvanceAssignment advanceAssignment);
public List<AdvanceMeasurement> getAdvanceMeasurements();
public List<AdvanceAssigment> getAdvanceAssigments();
public List<AdvanceAssignment> getAdvanceAssignments();
public void init(OrderElement orderElement);
public void addNewLineAdvaceAssigment();
public void addNewLineAdvaceAssignment();
public void addNewLineAdvaceMeasurement();
public void removeLineAdvanceAssigment(AdvanceAssigment advance);
public void removeLineAdvanceAssignment(AdvanceAssignment advance);
public void removeLineAdvanceMeasurement(AdvanceMeasurement advance);
@ -49,14 +49,14 @@ public interface IManageOrderElementAdvancesModel {
public BigDecimal getUnitPrecision();
public AdvanceMeasurement getFirstAdvanceMeasurement(
AdvanceAssigment advanceAssigment);
AdvanceAssignment advanceAssignment);
public void sortListAdvanceMeasurement();
public String getInfoAdvanceAssigment();
public String getInfoAdvanceAssignment();
public void accept()throws InstanceNotFoundException,
DuplicateAdvanceAssigmentForOrderElementException,
DuplicateAdvanceAssignmentForOrderElementException,
DuplicateValueTrueReportGlobalAdvanceException;
public BigDecimal getPercentageAdvanceMeasurement(

98
navalplanner-webapp/src/main/java/org/navalplanner/web/orders/ManageOrderElementAdvancesController.java
View file

@ -8,10 +8,10 @@ import java.util.Date;
import java.util.List;
import org.joda.time.LocalDate;
import org.navalplanner.business.advance.entities.AdvanceAssigment;
import org.navalplanner.business.advance.entities.AdvanceAssignment;
import org.navalplanner.business.advance.entities.AdvanceMeasurement;
import org.navalplanner.business.advance.entities.AdvanceType;
import org.navalplanner.business.advance.exceptions.DuplicateAdvanceAssigmentForOrderElementException;
import org.navalplanner.business.advance.exceptions.DuplicateAdvanceAssignmentForOrderElementException;
import org.navalplanner.business.advance.exceptions.DuplicateValueTrueReportGlobalAdvanceException;
import org.navalplanner.web.common.IMessagesForUser;
import org.navalplanner.web.common.Level;
@ -69,8 +69,8 @@ public class ManageOrderElementAdvancesController extends
return manageOrderElementAdvancesModel.getAdvanceMeasurements();
}
public List<AdvanceAssigment> getAdvanceAssigments() {
return manageOrderElementAdvancesModel.getAdvanceAssigments();
public List<AdvanceAssignment> getAdvanceAssignments() {
return manageOrderElementAdvancesModel.getAdvanceAssignments();
}
public void cancel() {
@ -93,7 +93,7 @@ public class ManageOrderElementAdvancesController extends
this.manageOrderElementAdvancesModel.accept();
window.setVisible(false);
Util.reloadBindings(window.getParent());
}catch(DuplicateAdvanceAssigmentForOrderElementException e){
}catch(DuplicateAdvanceAssignmentForOrderElementException e){
messagesForUser.showMessage( Level.INFO, _("It not must be include Advance with the same advance type."));
return;
}catch(DuplicateValueTrueReportGlobalAdvanceException e){
@ -111,16 +111,16 @@ public class ManageOrderElementAdvancesController extends
Util.reloadBindings(window);
}
public void prepareEditAdvanceMeasurements(AdvanceAssigment advanceAssigment) {
public void prepareEditAdvanceMeasurements(AdvanceAssignment advanceAssignment) {
manageOrderElementAdvancesModel
.prepareEditAdvanceMeasurements(advanceAssigment);
.prepareEditAdvanceMeasurements(advanceAssignment);
Listbox listAdvances = ((Listbox) window.getFellow("editAdvances"));
this.indexSelectedItem = listAdvances.getIndexOfItem(listAdvances.getSelectedItem());
Util.reloadBindings(window);
}
public void goToCreateLineAdvanceAssigment() {
manageOrderElementAdvancesModel.addNewLineAdvaceAssigment();
public void goToCreateLineAdvanceAssignment() {
manageOrderElementAdvancesModel.addNewLineAdvaceAssignment();
manageOrderElementAdvancesModel.prepareEditAdvanceMeasurements(null);
this.indexSelectedItem = -1;
Util.reloadBindings(window);
@ -131,15 +131,15 @@ public class ManageOrderElementAdvancesController extends
Util.reloadBindings(window);
}
public void goToRemoveLineAdvanceAssigment(){
public void goToRemoveLineAdvanceAssignment(){
Listbox listAdvances = (Listbox) window.getFellow("editAdvances");
Listitem listItem = listAdvances.getItemAtIndex(indexSelectedItem);
if(listItem != null){
AdvanceAssigment advanceAssigment = (AdvanceAssigment) listItem
AdvanceAssignment advanceAssignment = (AdvanceAssignment) listItem
.getValue();
manageOrderElementAdvancesModel
.removeLineAdvanceAssigment(advanceAssigment);
.removeLineAdvanceAssignment(advanceAssignment);
Util.reloadBindings(window);
}
}
@ -159,7 +159,7 @@ public class ManageOrderElementAdvancesController extends
}
public String getInfoAdvance() {
return manageOrderElementAdvancesModel.getInfoAdvanceAssigment();
return manageOrderElementAdvancesModel.getInfoAdvanceAssignment();
}
public List<AdvanceType> getActivesAdvanceType() {
@ -184,12 +184,12 @@ public class ManageOrderElementAdvancesController extends
public class AdvanceTypeListRenderer implements ListitemRenderer {
@Override
public void render(Listitem listItem, Object data) throws Exception {
final AdvanceAssigment advance = (AdvanceAssigment) data;
final AdvanceAssignment advance = (AdvanceAssignment) data;
listItem.setValue(advance);
listItem.setDraggable("true");
listItem.setDroppable("true");
if (advance.getType().equals(AdvanceAssigment.Type.DIRECT)) {
if (advance.getType().equals(AdvanceAssignment.Type.DIRECT)) {
appendComboboxAdvancType(listItem);
} else {
appendLabelAdvanceType(listItem);
@ -204,7 +204,7 @@ public class ManageOrderElementAdvancesController extends
}
private void appendComboboxAdvancType(final Listitem listItem){
final AdvanceAssigment advance = (AdvanceAssigment) listItem.getValue();
final AdvanceAssignment advance = (AdvanceAssignment) listItem.getValue();
final Combobox comboAdvanceTypes = new Combobox();
final List<AdvanceType> listAdvanceType = manageOrderElementAdvancesModel
.getActivesAdvanceTypes();
@ -252,7 +252,7 @@ public class ManageOrderElementAdvancesController extends
}
private void appendLabelAdvanceType(final Listitem listItem){
final AdvanceAssigment advance = (AdvanceAssigment) listItem.getValue();
final AdvanceAssignment advance = (AdvanceAssignment) listItem.getValue();
Label unitName = new Label(advance.getAdvanceType().getUnitName());
Listcell listCell = new Listcell();
listCell.appendChild(unitName);
@ -260,25 +260,25 @@ public class ManageOrderElementAdvancesController extends
}
private void appendDecimalBoxMaxValue(final Listitem listItem){
final AdvanceAssigment advanceAssigment = (AdvanceAssigment) listItem
final AdvanceAssignment advanceAssignment = (AdvanceAssignment) listItem
.getValue();
Decimalbox maxValue = new Decimalbox();
maxValue.setScale(2);
if(advanceAssigment.getType().equals(AdvanceAssigment.Type.CALCULATED))
if(advanceAssignment.getType().equals(AdvanceAssignment.Type.CALCULATED))
maxValue.setDisabled(true);
Util.bind(maxValue,
new Util.Getter<BigDecimal>() {
@Override
public BigDecimal get() {
return advanceAssigment.getMaxValue();
return advanceAssignment.getMaxValue();
}
}, new Util.Setter<BigDecimal>() {
@Override
public void set(BigDecimal value) {
advanceAssigment.setMaxValue(value);
advanceAssignment.setMaxValue(value);
}
});
maxValue.addEventListener(Events.ON_CHANGE,
@ -296,14 +296,14 @@ public class ManageOrderElementAdvancesController extends
}
private void appendDecimalBoxValue(final Listitem listItem){
final AdvanceAssigment advanceAssigment = (AdvanceAssigment) listItem
final AdvanceAssignment advanceAssignment = (AdvanceAssignment) listItem
.getValue();
Decimalbox value = new Decimalbox();
value.setScale(2);
value.setDisabled(true);
final AdvanceMeasurement advanceMeasurement = this.manageOrderElementAdvancesModel
.getFirstAdvanceMeasurement(advanceAssigment);
.getFirstAdvanceMeasurement(advanceAssignment);
if (advanceMeasurement != null) {
Util.bind(value, new Util.Getter<BigDecimal>() {
@Override
@ -324,12 +324,12 @@ public class ManageOrderElementAdvancesController extends
}
private void appendLabelPercentage(final Listitem listItem){
final AdvanceAssigment advanceAssigment = (AdvanceAssigment) listItem
final AdvanceAssignment advanceAssignment = (AdvanceAssignment) listItem
.getValue();
Label percentage = new Label();
final AdvanceMeasurement advanceMeasurement = this.manageOrderElementAdvancesModel
.getFirstAdvanceMeasurement(advanceAssigment);
.getFirstAdvanceMeasurement(advanceAssignment);
if (advanceMeasurement != null) {
percentage
.setValue(this.manageOrderElementAdvancesModel
@ -344,13 +344,13 @@ public class ManageOrderElementAdvancesController extends
}
private void appendDateBoxDate(final Listitem listItem){
final AdvanceAssigment advanceAssigment = (AdvanceAssigment) listItem
final AdvanceAssignment advanceAssignment = (AdvanceAssignment) listItem
.getValue();
Datebox date = new Datebox();
date.setDisabled(true);
final AdvanceMeasurement advanceMeasurement = this.manageOrderElementAdvancesModel
.getFirstAdvanceMeasurement(advanceAssigment);
.getFirstAdvanceMeasurement(advanceAssignment);
if (advanceMeasurement != null) {
Util.bind(date, new Util.Getter<Date>() {
@ -373,13 +373,13 @@ public class ManageOrderElementAdvancesController extends
}
private void appendRadioSpread(final Listitem listItem){
final AdvanceAssigment advanceAssigment = (AdvanceAssigment) listItem
final AdvanceAssignment advanceAssignment = (AdvanceAssignment) listItem
.getValue();
Radio reportGlobalAdvance = new Radio();
reportGlobalAdvance.setChecked(advanceAssigment
reportGlobalAdvance.setChecked(advanceAssignment
.getReportGlobalAdvance());
if (advanceAssigment.getType().equals(AdvanceAssigment.Type.CALCULATED))
if (advanceAssignment.getType().equals(AdvanceAssignment.Type.CALCULATED))
reportGlobalAdvance.setDisabled(true);
reportGlobalAdvance.addEventListener(Events.ON_CHECK,
@ -395,10 +395,10 @@ public class ManageOrderElementAdvancesController extends
}
private void appendCalculatedCheckbox(final Listitem listItem){
final AdvanceAssigment advance = (AdvanceAssigment) listItem.getValue();
final AdvanceAssignment advance = (AdvanceAssignment) listItem.getValue();
Checkbox calculated = new Checkbox();
boolean isCalculated = advance.getType().equals(
AdvanceAssigment.Type.CALCULATED);
AdvanceAssignment.Type.CALCULATED);
calculated.setChecked(isCalculated);
calculated.setDisabled(true);
@ -414,7 +414,7 @@ public class ManageOrderElementAdvancesController extends
if(selectedItem != null){
AdvanceType advanceType = ((AdvanceType) selectedItem.getValue());
if(advanceType != null){
AdvanceAssigment advance = (AdvanceAssigment) item.getValue();
AdvanceAssignment advance = (AdvanceAssignment) item.getValue();
advance.setMaxValue(advanceType.getDefaultMaxValue());
miBox.setValue(advanceType.getDefaultMaxValue());
}
@ -426,11 +426,11 @@ public class ManageOrderElementAdvancesController extends
if ((this.indexSelectedItem < listAdvances.getItemCount())
&& (this.indexSelectedItem >= 0)) {
Listitem selectedItem = listAdvances.getItemAtIndex(indexSelectedItem);
AdvanceAssigment advanceAssigment = (AdvanceAssigment) selectedItem
AdvanceAssignment advanceAssignment = (AdvanceAssignment) selectedItem
.getValue();
final AdvanceMeasurement greatAdvanceMeasurement = this.manageOrderElementAdvancesModel
.getFirstAdvanceMeasurement(advanceAssigment);
.getFirstAdvanceMeasurement(advanceAssignment);
if (greatAdvanceMeasurement != null) {
Listcell percentage = (Listcell) selectedItem.getChildren()
.get(3);
@ -447,10 +447,10 @@ public class ManageOrderElementAdvancesController extends
if(this.indexSelectedItem >= 0){
Listbox listAdvances = ((Listbox) window.getFellow("editAdvances"));
Listitem selectedItem = listAdvances.getItemAtIndex(indexSelectedItem);
AdvanceAssigment advanceAssigment = (AdvanceAssigment) selectedItem
AdvanceAssignment advanceAssignment = (AdvanceAssignment) selectedItem
.getValue();
final AdvanceMeasurement greatAdvanceMeasurement = this.manageOrderElementAdvancesModel
.getFirstAdvanceMeasurement(advanceAssigment);
.getFirstAdvanceMeasurement(advanceAssignment);
if (greatAdvanceMeasurement != null) {
Listcell value = (Listcell)selectedItem.getChildren().get(2);
((Decimalbox) value.getFirstChild())
@ -473,11 +473,11 @@ public class ManageOrderElementAdvancesController extends
if(this.indexSelectedItem >= 0){
Listbox listAdvances = ((Listbox) window.getFellow("editAdvances"));
Listitem selectedItem = listAdvances.getItemAtIndex(indexSelectedItem);
AdvanceAssigment advanceAssigment = (AdvanceAssigment) selectedItem
AdvanceAssignment advanceAssignment = (AdvanceAssignment) selectedItem
.getValue();
final AdvanceMeasurement greatAdvanceMeasurement =
this.manageOrderElementAdvancesModel
.getFirstAdvanceMeasurement(advanceAssigment);
.getFirstAdvanceMeasurement(advanceAssignment);
if(greatAdvanceMeasurement != null){
Listcell date = (Listcell) selectedItem.getChildren().get(4);
LocalDate newDate = greatAdvanceMeasurement.getDate();
@ -513,28 +513,28 @@ public class ManageOrderElementAdvancesController extends
Radio radioSpread = ((Radio)celdaSpread.getFirstChild());
if(!radioSpread.isDisabled()){
radioSpread.setChecked(false);
((AdvanceAssigment) listItem.getValue())
((AdvanceAssignment) listItem.getValue())
.setReportGlobalAdvance(false);
}
}
}
Listcell celdaSpread = (Listcell) item.getChildren().get(5);
((Radio)celdaSpread.getFirstChild()).setChecked(true);
((AdvanceAssigment) item.getValue()).setReportGlobalAdvance(true);
((AdvanceAssignment) item.getValue()).setReportGlobalAdvance(true);
}
private boolean validateDataForm(){
return ((validateListAdvanceAssigment())
return ((validateListAdvanceAssignment())
&&(validateListAdvanceMeasurement()));
}
private boolean validateListAdvanceAssigment(){
private boolean validateListAdvanceAssignment(){
Listbox listAdvances = (Listbox) window.getFellow("editAdvances");
for(int i=0; i< listAdvances.getChildren().size(); i++){
if(listAdvances.getChildren().get(i) instanceof Listitem){
Listitem listItem = (Listitem) listAdvances.getChildren().get(i);
AdvanceAssigment advance = (AdvanceAssigment) listItem
AdvanceAssignment advance = (AdvanceAssignment) listItem
.getValue();
if (advance.getAdvanceType() == null)
return false;
@ -567,12 +567,12 @@ public class ManageOrderElementAdvancesController extends
for(int i=0; i< listAdvances.getChildren().size(); i++){
if(listAdvances.getChildren().get(i) instanceof Listitem){
Listitem listItem = (Listitem) listAdvances.getChildren().get(i);
AdvanceAssigment advanceAssigment = (AdvanceAssigment) listItem
AdvanceAssignment advanceAssignment = (AdvanceAssignment) listItem
.getValue();
if (advanceAssigment.getType().equals(
AdvanceAssigment.Type.DIRECT)) {
if (advanceAssignment.getType().equals(
AdvanceAssignment.Type.DIRECT)) {
existItems = true;
if (advanceAssigment.getReportGlobalAdvance()) {
if (advanceAssignment.getReportGlobalAdvance()) {
return true;
}
}
@ -723,7 +723,7 @@ public class ManageOrderElementAdvancesController extends
advanceMeasurement)) {
throw new WrongValueException(
comp,
_("The date is not valid, the date must be unique for this advance assigment"));
_("The date is not valid, the date must be unique for this advance assignment"));
}
}
}

182
navalplanner-webapp/src/main/java/org/navalplanner/web/orders/ManageOrderElementAdvancesModel.java
View file

@ -13,14 +13,14 @@ import java.util.TreeSet;
import org.apache.commons.lang.Validate;
import org.joda.time.LocalDate;
import org.navalplanner.business.advance.daos.IAdvanceAssigmentDAO;
import org.navalplanner.business.advance.daos.IAdvanceAssignmentDAO;
import org.navalplanner.business.advance.daos.IAdvanceMeasurementDAO;
import org.navalplanner.business.advance.daos.IAdvanceTypeDAO;
import org.navalplanner.business.advance.entities.AdvanceAssigment;
import org.navalplanner.business.advance.entities.AdvanceAssignment;
import org.navalplanner.business.advance.entities.AdvanceMeasurement;
import org.navalplanner.business.advance.entities.AdvanceMeasurementComparator;
import org.navalplanner.business.advance.entities.AdvanceType;
import org.navalplanner.business.advance.exceptions.DuplicateAdvanceAssigmentForOrderElementException;
import org.navalplanner.business.advance.exceptions.DuplicateAdvanceAssignmentForOrderElementException;
import org.navalplanner.business.advance.exceptions.DuplicateValueTrueReportGlobalAdvanceException;
import org.navalplanner.business.common.exceptions.InstanceNotFoundException;
import org.navalplanner.business.orders.daos.IOrderElementDAO;
@ -47,9 +47,9 @@ public class ManageOrderElementAdvancesModel implements
private OrderElement orderElement;
private AdvanceAssigment advanceAssigment;
private AdvanceAssignment advanceAssignment;
private List<AdvanceAssigment> listAdvanceAssigments;
private List<AdvanceAssignment> listAdvanceAssignments;
private SortedSet<AdvanceMeasurement> listAdvanceMeasurements;
@ -60,68 +60,68 @@ public class ManageOrderElementAdvancesModel implements
IAdvanceMeasurementDAO advanceMeasurementDAO,
IAdvanceTypeDAO advanceTypeDAO,
IOrderElementDAO orderElementDAO,
IAdvanceAssigmentDAO advanceAssigmentDAO) {
IAdvanceAssignmentDAO advanceAssignmentDAO) {
Validate.notNull(advanceMeasurementDAO);
this.advanceTypeDAO = advanceTypeDAO;
this.orderElementDAO = orderElementDAO;
}
@Override
public String getInfoAdvanceAssigment(){
if ((this.advanceAssigment == null) ||
public String getInfoAdvanceAssignment(){
if ((this.advanceAssignment == null) ||
(this.orderElement == null)) {
return "";
}
if ((this.advanceAssigment.getAdvanceType() == null)
|| this.advanceAssigment.getMaxValue() == null) {
if ((this.advanceAssignment.getAdvanceType() == null)
|| this.advanceAssignment.getMaxValue() == null) {
return "";
}
return " " + this.advanceAssigment.getAdvanceType().getUnitName()
+ _(". Max value: ") + this.advanceAssigment.getMaxValue();
return " " + this.advanceAssignment.getAdvanceType().getUnitName()
+ _(". Max value: ") + this.advanceAssignment.getMaxValue();
}
@Override
@Transactional(readOnly = true)
public List<AdvanceMeasurement> getAdvanceMeasurements() {
if ((this.advanceAssigment == null) ||
if ((this.advanceAssignment == null) ||
(this.orderElement == null)) {
return new ArrayList<AdvanceMeasurement>();
}
return new ArrayList<AdvanceMeasurement>(this.advanceAssigment
return new ArrayList<AdvanceMeasurement>(this.advanceAssignment
.getAdvanceMeasurements());
}
@Override
@Transactional(readOnly = true)
public List<AdvanceAssigment> getAdvanceAssigments() {
public List<AdvanceAssignment> getAdvanceAssignments() {
if (orderElement == null) {
return new ArrayList<AdvanceAssigment>();
return new ArrayList<AdvanceAssignment>();
}
return listAdvanceAssigments;
return listAdvanceAssignments;
}
@Override
public void prepareEditAdvanceMeasurements(AdvanceAssigment advanceAssigment) {
this.advanceAssigment = advanceAssigment;
public void prepareEditAdvanceMeasurements(AdvanceAssignment advanceAssignment) {
this.advanceAssignment = advanceAssignment;
}
@Override
@Transactional(readOnly = true)
public void init(OrderElement orderElement) {
this.orderElement = orderElement;
this.advanceAssigment = null;
this.advanceAssignment = null;
if (orderElement != null){
loadAdvanceTypes();
reattachmentOrderElement();
forceLoadAdvanceAssigmentsAndMeasurements();
forceLoadAdvanceAssignmentsAndMeasurements();
fillVariables();
}
}
private void forceLoadAdvanceAssigmentsAndMeasurements() {
for (AdvanceAssigment advanceAssigment : orderElement
.getAdvanceAssigments()) {
advanceAssigment.getAdvanceMeasurements().size();
private void forceLoadAdvanceAssignmentsAndMeasurements() {
for (AdvanceAssignment advanceAssignment : orderElement
.getAdvanceAssignments()) {
advanceAssignment.getAdvanceMeasurements().size();
}
}
@ -130,13 +130,13 @@ public class ManageOrderElementAdvancesModel implements
}
private void fillVariables() {
this.listAdvanceAssigments = new ArrayList<AdvanceAssigment>();
this.listAdvanceAssignments = new ArrayList<AdvanceAssignment>();
this.listAdvanceMeasurements = new TreeSet<AdvanceMeasurement>(
new AdvanceMeasurementComparator());
for (AdvanceAssigment advanceAssigment : this.orderElement
.getAdvanceAssigments()) {
this.listAdvanceAssigments.add(advanceAssigment);
for (AdvanceMeasurement advanceMeasurement : advanceAssigment
for (AdvanceAssignment advanceAssignment : this.orderElement
.getAdvanceAssignments()) {
this.listAdvanceAssignments.add(advanceAssignment);
for (AdvanceMeasurement advanceMeasurement : advanceAssignment
.getAdvanceMeasurements()) {
this.listAdvanceMeasurements.add(advanceMeasurement);
}
@ -144,33 +144,33 @@ public class ManageOrderElementAdvancesModel implements
}
@Override
public void addNewLineAdvaceAssigment() {
AdvanceAssigment newAdvance = AdvanceAssigment.create();
newAdvance.setType(AdvanceAssigment.Type.DIRECT);
public void addNewLineAdvaceAssignment() {
AdvanceAssignment newAdvance = AdvanceAssignment.create();
newAdvance.setType(AdvanceAssignment.Type.DIRECT);
newAdvance.setOrderElement(this.orderElement);
listAdvanceAssigments.add(newAdvance);
listAdvanceAssignments.add(newAdvance);
}
@Override
public void addNewLineAdvaceMeasurement() {
if (this.advanceAssigment != null) {
if (this.advanceAssignment != null) {
AdvanceMeasurement newMeasurement = AdvanceMeasurement.create();
newMeasurement.setDate(new LocalDate());
newMeasurement.setAdvanceAssigment(this.advanceAssigment);
this.advanceAssigment.getAdvanceMeasurements().add(newMeasurement);
newMeasurement.setAdvanceAssignment(this.advanceAssignment);
this.advanceAssignment.getAdvanceMeasurements().add(newMeasurement);
}
}
@Override
public void removeLineAdvanceAssigment(AdvanceAssigment advance) {
this.listAdvanceAssigments.remove(advance);
this.advanceAssigment = null;
public void removeLineAdvanceAssignment(AdvanceAssignment advance) {
this.listAdvanceAssignments.remove(advance);
this.advanceAssignment = null;
}
@Override
public void removeLineAdvanceMeasurement(AdvanceMeasurement advance) {
this.advanceAssigment.getAdvanceMeasurements().remove(advance);
this.advanceAssignment.getAdvanceMeasurements().remove(advance);
}
@Override
@ -188,18 +188,18 @@ public class ManageOrderElementAdvancesModel implements
@Override
public boolean isReadOnlyAdvanceMeasurements(){
if (this.advanceAssigment == null)
if (this.advanceAssignment == null)
return true;
return this.advanceAssigment.getType().equals(
AdvanceAssigment.Type.CALCULATED);
return this.advanceAssignment.getType().equals(
AdvanceAssignment.Type.CALCULATED);
}
@Override
public void cleanAdvance(){
if (this.advanceAssigment != null) {
this.advanceAssigment.setReportGlobalAdvance(false);
if (this.advanceAssignment != null) {
this.advanceAssignment.setReportGlobalAdvance(false);
List<AdvanceMeasurement> listAdvanceMeasurements = new ArrayList<AdvanceMeasurement>(
this.advanceAssigment.getAdvanceMeasurements());
this.advanceAssignment.getAdvanceMeasurements());
for (AdvanceMeasurement advanceMeasurement : listAdvanceMeasurements) {
advanceMeasurement.setValue(BigDecimal.ZERO);
advanceMeasurement.setDate(null);
@ -210,7 +210,7 @@ public class ManageOrderElementAdvancesModel implements
@Override
@Transactional(readOnly = true)
public void accept()throws InstanceNotFoundException,
DuplicateAdvanceAssigmentForOrderElementException,
DuplicateAdvanceAssignmentForOrderElementException,
DuplicateValueTrueReportGlobalAdvanceException{
orderElementDAO.checkVersion(orderElement);
reattachmentOrderElement();
@ -218,20 +218,20 @@ public class ManageOrderElementAdvancesModel implements
}
private void validateBasicData() throws InstanceNotFoundException,
DuplicateAdvanceAssigmentForOrderElementException,
DuplicateAdvanceAssignmentForOrderElementException,
DuplicateValueTrueReportGlobalAdvanceException{
updateRemoveAdvances();
for (AdvanceAssigment advanceAssigment : this.listAdvanceAssigments) {
if(advanceAssigment.getType().equals(AdvanceAssigment.Type.DIRECT))
validateBasicData(advanceAssigment);
for (AdvanceAssignment advanceAssignment : this.listAdvanceAssignments) {
if(advanceAssignment.getType().equals(AdvanceAssignment.Type.DIRECT))
validateBasicData(advanceAssignment);
}
}
private void updateRemoveAdvances(){
for(AdvanceAssigment advanceAssigment : this.listAdvanceAssigments){
AdvanceAssigment advance = yetExistAdvanceAssigment(advanceAssigment);
for(AdvanceAssignment advanceAssignment : this.listAdvanceAssignments){
AdvanceAssignment advance = yetExistAdvanceAssignment(advanceAssignment);
if (advance == null) {
removeAdvanceAssigment(advance);
removeAdvanceAssignment(advance);
}else{
for(AdvanceMeasurement advanceMeasurement : this.listAdvanceMeasurements){
if (!yetExistAdvanceMeasurement(advance, advanceMeasurement)) {
@ -242,27 +242,27 @@ public class ManageOrderElementAdvancesModel implements
}
}
private void validateBasicData(AdvanceAssigment advanceAssigment)
throws InstanceNotFoundException,DuplicateAdvanceAssigmentForOrderElementException,
private void validateBasicData(AdvanceAssignment advanceAssignment)
throws InstanceNotFoundException,DuplicateAdvanceAssignmentForOrderElementException,
DuplicateValueTrueReportGlobalAdvanceException{
if (advanceAssigment.getVersion() == null) {
addAdvanceAssigment(advanceAssigment);
if (advanceAssignment.getVersion() == null) {
addAdvanceAssignment(advanceAssignment);
}
}
private AdvanceAssigment yetExistAdvanceAssigment(
AdvanceAssigment advanceAssigment) {
for (AdvanceAssigment advance : this.orderElement
.getAdvanceAssigments()) {
if ((advance.getId() == advanceAssigment.getId()))
private AdvanceAssignment yetExistAdvanceAssignment(
AdvanceAssignment advanceAssignment) {
for (AdvanceAssignment advance : this.orderElement
.getAdvanceAssignments()) {
if ((advance.getId() == advanceAssignment.getId()))
return advance;
}
return null;
}
private boolean yetExistAdvanceMeasurement(AdvanceAssigment advanceAssigment,
private boolean yetExistAdvanceMeasurement(AdvanceAssignment advanceAssignment,
AdvanceMeasurement advanceMeasurement){
for (AdvanceMeasurement advance : advanceAssigment
for (AdvanceMeasurement advance : advanceAssignment
.getAdvanceMeasurements()) {
if (advance.getId() == advanceMeasurement.getId()) {
return true;
@ -272,26 +272,26 @@ public class ManageOrderElementAdvancesModel implements
}
@Transactional(readOnly = true)
private void addAdvanceAssigment(AdvanceAssigment newAdvanceAssigment)
throws DuplicateAdvanceAssigmentForOrderElementException,
private void addAdvanceAssignment(AdvanceAssignment newAdvanceAssignment)
throws DuplicateAdvanceAssignmentForOrderElementException,
DuplicateValueTrueReportGlobalAdvanceException{
this.orderElement.addAdvanceAssigment(newAdvanceAssigment);
this.orderElement.addAdvanceAssignment(newAdvanceAssignment);
}
private void removeAdvanceAssigment(AdvanceAssigment advanceAssigment){
orderElement.removeAdvanceAssigment(advanceAssigment);
private void removeAdvanceAssignment(AdvanceAssignment advanceAssignment){
orderElement.removeAdvanceAssignment(advanceAssignment);
}
private void removeAdvanceMeasurement(AdvanceMeasurement advanceMeasurement){
AdvanceAssigment advanceAssigment = advanceMeasurement.getAdvanceAssigment();
advanceAssigment.getAdvanceMeasurements().remove(advanceMeasurement);
AdvanceAssignment advanceAssignment = advanceMeasurement.getAdvanceAssignment();
advanceAssignment.getAdvanceMeasurements().remove(advanceMeasurement);
}
@Override
public boolean isPrecisionValid(BigDecimal value){
if ((this.advanceAssigment != null)
&& (this.advanceAssigment.getAdvanceType() != null)) {
BigDecimal precision = this.advanceAssigment.getAdvanceType()
if ((this.advanceAssignment != null)
&& (this.advanceAssignment.getAdvanceType() != null)) {
BigDecimal precision = this.advanceAssignment.getAdvanceType()
.getUnitPrecision();
BigDecimal result[] = value.divideAndRemainder(precision);
if(result[1].compareTo(BigDecimal.ZERO) == 0) return true;
@ -302,10 +302,10 @@ public class ManageOrderElementAdvancesModel implements
@Override
public boolean greatThanMaxValue(BigDecimal value){
if ((this.advanceAssigment == null)
|| (this.advanceAssigment.getMaxValue() == null))
if ((this.advanceAssignment == null)
|| (this.advanceAssignment.getMaxValue() == null))
return false;
if (value.compareTo(this.advanceAssigment.getMaxValue()) > 0)
if (value.compareTo(this.advanceAssignment.getMaxValue()) > 0)
return true;
return false;
}
@ -313,9 +313,9 @@ public class ManageOrderElementAdvancesModel implements
@Override
public boolean isDistinctValidDate(Date value,
AdvanceMeasurement newAdvanceMeasurement) {
if (this.advanceAssigment == null)
if (this.advanceAssignment == null)
return true;
for (AdvanceMeasurement advanceMeasurement : advanceAssigment
for (AdvanceMeasurement advanceMeasurement : advanceAssignment
.getAdvanceMeasurements()) {
LocalDate oldDate = advanceMeasurement.getDate();
if ((oldDate != null)
@ -328,17 +328,17 @@ public class ManageOrderElementAdvancesModel implements
@Override
public BigDecimal getUnitPrecision(){
if (this.advanceAssigment == null) {
if (this.advanceAssignment == null) {
return new BigDecimal(0);
}
return this.advanceAssigment.getAdvanceType().getUnitPrecision();
return this.advanceAssignment.getAdvanceType().getUnitPrecision();
}
@Override
public AdvanceMeasurement getFirstAdvanceMeasurement(AdvanceAssigment advanceAssigment){
if((advanceAssigment != null) &&
(advanceAssigment.getAdvanceMeasurements().size() > 0)) {
SortedSet<AdvanceMeasurement> listAM = (SortedSet<AdvanceMeasurement>) advanceAssigment.getAdvanceMeasurements();
public AdvanceMeasurement getFirstAdvanceMeasurement(AdvanceAssignment advanceAssignment){
if((advanceAssignment != null) &&
(advanceAssignment.getAdvanceMeasurements().size() > 0)) {
SortedSet<AdvanceMeasurement> listAM = (SortedSet<AdvanceMeasurement>) advanceAssignment.getAdvanceMeasurements();
final AdvanceMeasurement advanceMeasurement = (AdvanceMeasurement) listAM.first();
return advanceMeasurement;
}
@ -348,24 +348,24 @@ public class ManageOrderElementAdvancesModel implements
@Override
public void sortListAdvanceMeasurement() {
ArrayList<AdvanceMeasurement> advanceMeasurements = new ArrayList<AdvanceMeasurement>(
this.advanceAssigment.getAdvanceMeasurements());
this.advanceAssignment.getAdvanceMeasurements());
Collections.sort(advanceMeasurements,
new AdvanceMeasurementComparator());
TreeSet<AdvanceMeasurement> measurements = new TreeSet<AdvanceMeasurement>(
new AdvanceMeasurementComparator());
measurements.addAll(advanceMeasurements);
this.advanceAssigment
this.advanceAssignment
.setAdvanceMeasurements(measurements);
}
@Override
public BigDecimal getPercentageAdvanceMeasurement(
AdvanceMeasurement advanceMeasurement) {
if (advanceMeasurement.getAdvanceAssigment() == null) {
if (advanceMeasurement.getAdvanceAssignment() == null) {
return BigDecimal.ZERO;
}
BigDecimal maxValue = advanceMeasurement.getAdvanceAssigment()
BigDecimal maxValue = advanceMeasurement.getAdvanceAssignment()
.getMaxValue();
if (maxValue.compareTo(BigDecimal.ZERO) <= 0) {
return BigDecimal.ZERO;

6
navalplanner-webapp/src/main/java/org/navalplanner/web/planner/SaveCommand.java
View file

@ -6,7 +6,7 @@ import java.util.List;
import org.navalplanner.business.common.exceptions.InstanceNotFoundException;
import org.navalplanner.business.planner.daos.ITaskElementDAO;
import org.navalplanner.business.planner.entities.DayAssigment;
import org.navalplanner.business.planner.entities.DayAssignment;
import org.navalplanner.business.planner.entities.ResourceAllocation;
import org.navalplanner.business.planner.entities.Task;
import org.navalplanner.business.planner.entities.TaskElement;
@ -50,9 +50,9 @@ public class SaveCommand implements ISaveCommand {
for (ResourceAllocation resourceAllocation : ((Task) taskElement)
.getResourceAllocations()) {
resourceAllocation.dontPoseAsTransientObjectAnymore();
for (DayAssigment dayAssigment : (List<? extends DayAssigment>) resourceAllocation
for (DayAssignment dayAssignment : (List<? extends DayAssignment>) resourceAllocation
.getAssignments()) {
dayAssigment.dontPoseAsTransientObjectAnymore();
dayAssignment.dontPoseAsTransientObjectAnymore();
}
}
}

8
navalplanner-webapp/src/main/webapp/orders/_listOrderElementAdvances.zul
View file

@ -3,18 +3,18 @@
<separator bar="true" spacing="2px" orient="horizontal"/>
<vbox align="left">
<hbox>
<button label="${i18n:_('Add new advance assigment')}"
onClick="manageOrderElementAdvancesController.goToCreateLineAdvanceAssigment();">
<button label="${i18n:_('Add new advance assignment')}"
onClick="manageOrderElementAdvancesController.goToCreateLineAdvanceAssignment();">
</button>
<button label="${i18n:_('Remove')}"
onClick="manageOrderElementAdvancesController.goToRemoveLineAdvanceAssigment();"
onClick="manageOrderElementAdvancesController.goToRemoveLineAdvanceAssignment();"
disabled = "@{manageOrderElementAdvancesController.isReadOnlyAdvanceMeasurements}">
</button>
</hbox>
</vbox>
<vbox>
<listbox id="editAdvances"
model="@{manageOrderElementAdvancesController.advanceAssigments}"
model="@{manageOrderElementAdvancesController.advanceAssignments}"
itemRenderer="@{manageOrderElementAdvancesController.advancesRenderer}" mold="paging"
onSelect="manageOrderElementAdvancesController.prepareEditAdvanceMeasurements(self.selectedItem.value);"
pageSize="10">

2
navalplanner-webapp/src/main/webapp/planner/main.zul
View file

@ -17,7 +17,7 @@
-->
<planner id="planner" self="@{define(content)}"
configuration="${plannerData.lightLoad}">
<div id="idContextMenuTaskAssigment"></div>
<div id="idContextMenuTaskAssignment"></div>
</planner>
<popup width="300px" apply="${plannerData.taskEditForm}">

2
navalplanner-webapp/src/main/webapp/planner/order.zul
View file

@ -22,7 +22,7 @@
</zscript>
<planner id="planner" self="@{define(content)}">
<div id="idContextMenuTaskAssigment"></div>
<div id="idContextMenuTaskAssignment"></div>
</planner>
<popup width="300px" apply="${planningController.editTaskController}">

2
navalplanner-webapp/src/main/webapp/planner/resources_use.zul
View file

@ -8,7 +8,7 @@
<zk>
<resourcesLoadPanel id="planner" self="@{define(content)}">
<div id="idContextMenuTaskAssigment"></div>
<div id="idContextMenuTaskAssignment"></div>
</resourcesLoadPanel>
</zk>