diff --git a/ganttzk-demo-webapp/src/main/webapp/planner/main.zul b/ganttzk-demo-webapp/src/main/webapp/planner/main.zul
index 247fb26b8..b7b642791 100644
--- a/ganttzk-demo-webapp/src/main/webapp/planner/main.zul
+++ b/ganttzk-demo-webapp/src/main/webapp/planner/main.zul
@@ -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}">
diff --git a/ganttzk/src/main/java/org/zkoss/ganttz/TaskAssigmentMoveCommand.java b/ganttzk/src/main/java/org/zkoss/ganttz/TaskAssignmentMoveCommand.java
similarity index 70%
rename from ganttzk/src/main/java/org/zkoss/ganttz/TaskAssigmentMoveCommand.java
rename to ganttzk/src/main/java/org/zkoss/ganttz/TaskAssignmentMoveCommand.java
index d66c03e94..2243fd456 100644
--- a/ganttzk/src/main/java/org/zkoss/ganttz/TaskAssigmentMoveCommand.java
+++ b/ganttzk/src/main/java/org/zkoss/ganttz/TaskAssignmentMoveCommand.java
@@ -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);
     }
 
diff --git a/ganttzk/src/main/java/org/zkoss/ganttz/TaskComponent.java b/ganttzk/src/main/java/org/zkoss/ganttz/TaskComponent.java
index 4eb899514..a76d13e65 100755
--- a/ganttzk/src/main/java/org/zkoss/ganttz/TaskComponent.java
+++ b/ganttzk/src/main/java/org/zkoss/ganttz/TaskComponent.java
@@ -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());
diff --git a/ganttzk/src/main/resources/web/ganttz/css/task.css.dsp b/ganttzk/src/main/resources/web/ganttz/css/task.css.dsp
index cfe4eafa7..747fb6d08 100755
--- a/ganttzk/src/main/resources/web/ganttz/css/task.css.dsp
+++ b/ganttzk/src/main/resources/web/ganttz/css/task.css.dsp
@@ -1,5 +1,5 @@
 <style>
-.z-taskassigment-normal {
+.z-taskassignment-normal {
     cursos: move;
     border: 2px solid #538BA2;
     background-color: #BBBBBB;
diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/advance/daos/AdvanceAssigmentDAO.java b/navalplanner-business/src/main/java/org/navalplanner/business/advance/daos/AdvanceAssignmentDAO.java
similarity index 62%
rename from navalplanner-business/src/main/java/org/navalplanner/business/advance/daos/AdvanceAssigmentDAO.java
rename to navalplanner-business/src/main/java/org/navalplanner/business/advance/daos/AdvanceAssignmentDAO.java
index e08671f0a..6ca655d08 100644
--- a/navalplanner-business/src/main/java/org/navalplanner/business/advance/daos/AdvanceAssigmentDAO.java
+++ b/navalplanner-business/src/main/java/org/navalplanner/business/advance/daos/AdvanceAssignmentDAO.java
@@ -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 {
 }
\ No newline at end of file
diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/advance/daos/IAdvanceAssigmentDAO.java b/navalplanner-business/src/main/java/org/navalplanner/business/advance/daos/IAdvanceAssigmentDAO.java
deleted file mode 100644
index d4a801d9a..000000000
--- a/navalplanner-business/src/main/java/org/navalplanner/business/advance/daos/IAdvanceAssigmentDAO.java
+++ /dev/null
@@ -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> {
-}
\ No newline at end of file
diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/advance/daos/IAdvanceAssignmentDAO.java b/navalplanner-business/src/main/java/org/navalplanner/business/advance/daos/IAdvanceAssignmentDAO.java
new file mode 100644
index 000000000..525f9c7bc
--- /dev/null
+++ b/navalplanner-business/src/main/java/org/navalplanner/business/advance/daos/IAdvanceAssignmentDAO.java
@@ -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> {
+}
\ No newline at end of file
diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/advance/entities/AdvanceAssigment.java b/navalplanner-business/src/main/java/org/navalplanner/business/advance/entities/AdvanceAssignment.java
similarity index 82%
rename from navalplanner-business/src/main/java/org/navalplanner/business/advance/entities/AdvanceAssigment.java
rename to navalplanner-business/src/main/java/org/navalplanner/business/advance/entities/AdvanceAssignment.java
index 8be97c804..6c8005024 100644
--- a/navalplanner-business/src/main/java/org/navalplanner/business/advance/entities/AdvanceAssigment.java
+++ b/navalplanner-business/src/main/java/org/navalplanner/business/advance/entities/AdvanceAssignment.java
@@ -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);
diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/advance/entities/AdvanceMeasurement.java b/navalplanner-business/src/main/java/org/navalplanner/business/advance/entities/AdvanceMeasurement.java
index f245e4301..a07aba986 100644
--- a/navalplanner-business/src/main/java/org/navalplanner/business/advance/entities/AdvanceMeasurement.java
+++ b/navalplanner-business/src/main/java/org/navalplanner/business/advance/entities/AdvanceMeasurement.java
@@ -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;
     }
 
 }
diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/advance/exceptions/DuplicateAdvanceAssigmentForOrderElementException.java b/navalplanner-business/src/main/java/org/navalplanner/business/advance/exceptions/DuplicateAdvanceAssignmentForOrderElementException.java
similarity index 80%
rename from navalplanner-business/src/main/java/org/navalplanner/business/advance/exceptions/DuplicateAdvanceAssigmentForOrderElementException.java
rename to navalplanner-business/src/main/java/org/navalplanner/business/advance/exceptions/DuplicateAdvanceAssignmentForOrderElementException.java
index 6e41d78c9..7620ae6db 100644
--- a/navalplanner-business/src/main/java/org/navalplanner/business/advance/exceptions/DuplicateAdvanceAssigmentForOrderElementException.java
+++ b/navalplanner-business/src/main/java/org/navalplanner/business/advance/exceptions/DuplicateAdvanceAssignmentForOrderElementException.java
@@ -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());
     }
diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/OrderElement.java b/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/OrderElement.java
index 089ba5c38..75d4abff6 100644
--- a/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/OrderElement.java
+++ b/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/OrderElement.java
@@ -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);
             }
         }
     }
diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/OrderLine.java b/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/OrderLine.java
index a77f47584..2d1632c53 100644
--- a/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/OrderLine.java
+++ b/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/OrderLine.java
@@ -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();
     }
 
 }
diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/OrderLineGroup.java b/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/OrderLineGroup.java
index 3506fb2c6..3dc4c677e 100644
--- a/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/OrderLineGroup.java
+++ b/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/OrderLineGroup.java
@@ -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;
diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/planner/daos/AssigmentFunctionDAO.java b/navalplanner-business/src/main/java/org/navalplanner/business/planner/daos/AssignmentFunctionDAO.java
similarity index 61%
rename from navalplanner-business/src/main/java/org/navalplanner/business/planner/daos/AssigmentFunctionDAO.java
rename to navalplanner-business/src/main/java/org/navalplanner/business/planner/daos/AssignmentFunctionDAO.java
index ee0a076d2..a6bfb3a15 100644
--- a/navalplanner-business/src/main/java/org/navalplanner/business/planner/daos/AssigmentFunctionDAO.java
+++ b/navalplanner-business/src/main/java/org/navalplanner/business/planner/daos/AssignmentFunctionDAO.java
@@ -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 {
 
 }
diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/planner/daos/DayAssigmentDAO.java b/navalplanner-business/src/main/java/org/navalplanner/business/planner/daos/DayAssignmentDAO.java
similarity index 64%
rename from navalplanner-business/src/main/java/org/navalplanner/business/planner/daos/DayAssigmentDAO.java
rename to navalplanner-business/src/main/java/org/navalplanner/business/planner/daos/DayAssignmentDAO.java
index 0a2106ebc..454d43331 100644
--- a/navalplanner-business/src/main/java/org/navalplanner/business/planner/daos/DayAssigmentDAO.java
+++ b/navalplanner-business/src/main/java/org/navalplanner/business/planner/daos/DayAssignmentDAO.java
@@ -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 {
 
 }
diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/planner/daos/IAssigmentFunctionDAO.java b/navalplanner-business/src/main/java/org/navalplanner/business/planner/daos/IAssigmentFunctionDAO.java
deleted file mode 100644
index d8e7e4138..000000000
--- a/navalplanner-business/src/main/java/org/navalplanner/business/planner/daos/IAssigmentFunctionDAO.java
+++ /dev/null
@@ -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> {
-
-}
diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/planner/daos/IAssignmentFunctionDAO.java b/navalplanner-business/src/main/java/org/navalplanner/business/planner/daos/IAssignmentFunctionDAO.java
new file mode 100644
index 000000000..639cdd383
--- /dev/null
+++ b/navalplanner-business/src/main/java/org/navalplanner/business/planner/daos/IAssignmentFunctionDAO.java
@@ -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> {
+
+}
diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/planner/daos/IDayAssigmentDAO.java b/navalplanner-business/src/main/java/org/navalplanner/business/planner/daos/IDayAssigmentDAO.java
deleted file mode 100644
index fe3be1e99..000000000
--- a/navalplanner-business/src/main/java/org/navalplanner/business/planner/daos/IDayAssigmentDAO.java
+++ /dev/null
@@ -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> {
-
-}
diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/planner/daos/IDayAssignmentDAO.java b/navalplanner-business/src/main/java/org/navalplanner/business/planner/daos/IDayAssignmentDAO.java
new file mode 100644
index 000000000..d762ae05f
--- /dev/null
+++ b/navalplanner-business/src/main/java/org/navalplanner/business/planner/daos/IDayAssignmentDAO.java
@@ -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> {
+
+}
diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/planner/daos/ITaskElementDAO.java b/navalplanner-business/src/main/java/org/navalplanner/business/planner/daos/ITaskElementDAO.java
index 0a219772b..94b94a44b 100644
--- a/navalplanner-business/src/main/java/org/navalplanner/business/planner/daos/ITaskElementDAO.java
+++ b/navalplanner-business/src/main/java/org/navalplanner/business/planner/daos/ITaskElementDAO.java
@@ -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();
 
diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/planner/daos/TaskElementDAO.java b/navalplanner-business/src/main/java/org/navalplanner/business/planner/daos/TaskElementDAO.java
index a39c55469..f481133e2 100644
--- a/navalplanner-business/src/main/java/org/navalplanner/business/planner/daos/TaskElementDAO.java
+++ b/navalplanner-business/src/main/java/org/navalplanner/business/planner/daos/TaskElementDAO.java
@@ -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();
     }
 }
diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/AssigmentFunction.java b/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/AssigmentFunction.java
deleted file mode 100644
index ffc87820d..000000000
--- a/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/AssigmentFunction.java
+++ /dev/null
@@ -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() {
-
-    }
-}
diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/AssignmentFunction.java b/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/AssignmentFunction.java
new file mode 100644
index 000000000..2a3ca772e
--- /dev/null
+++ b/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/AssignmentFunction.java
@@ -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() {
+
+    }
+}
diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/DayAssigment.java b/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/DayAssignment.java
similarity index 71%
rename from navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/DayAssigment.java
rename to navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/DayAssignment.java
index 714c5c4a7..ec82f5008 100644
--- a/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/DayAssigment.java
+++ b/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/DayAssignment.java
@@ -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());
diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/GenericDayAssigment.java b/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/GenericDayAssignment.java
similarity index 74%
rename from navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/GenericDayAssigment.java
rename to navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/GenericDayAssignment.java
index 488cb134f..097056cac 100644
--- a/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/GenericDayAssigment.java
+++ b/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/GenericDayAssignment.java
@@ -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() {
 
     }
 
diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/GenericResourceAllocation.java b/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/GenericResourceAllocation.java
index ba704f92a..6a26fd689 100644
--- a/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/GenericResourceAllocation.java
+++ b/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/GenericResourceAllocation.java
@@ -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);
     }
 
 }
diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/ResourceAllocation.java b/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/ResourceAllocation.java
index a0bd4190a..79eb5fcb3 100644
--- a/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/ResourceAllocation.java
+++ b/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/ResourceAllocation.java
@@ -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() {
diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/SpecificDayAssigment.java b/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/SpecificDayAssignment.java
similarity index 74%
rename from navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/SpecificDayAssigment.java
rename to navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/SpecificDayAssignment.java
index f481beab7..ef8240a72 100644
--- a/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/SpecificDayAssigment.java
+++ b/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/SpecificDayAssignment.java
@@ -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() {
 
     }
 
diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/SpecificResourceAllocation.java b/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/SpecificResourceAllocation.java
index e804ef703..07387e469 100644
--- a/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/SpecificResourceAllocation.java
+++ b/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/SpecificResourceAllocation.java
@@ -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);
             }
         };
diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/resources/entities/Resource.java b/navalplanner-business/src/main/java/org/navalplanner/business/resources/entities/Resource.java
index 8a6ef658c..b9e0dc353 100644
--- a/navalplanner-business/src/main/java/org/navalplanner/business/resources/entities/Resource.java
+++ b/navalplanner-business/src/main/java/org/navalplanner/business/resources/entities/Resource.java
@@ -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);
     }
 
 }
diff --git a/navalplanner-business/src/main/resources/org/navalplanner/business/advance/entities/Advance.hbm.xml b/navalplanner-business/src/main/resources/org/navalplanner/business/advance/entities/Advance.hbm.xml
index 920f5774e..0202fecea 100644
--- a/navalplanner-business/src/main/resources/org/navalplanner/business/advance/entities/Advance.hbm.xml
+++ b/navalplanner-business/src/main/resources/org/navalplanner/business/advance/entities/Advance.hbm.xml
@@ -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>
diff --git a/navalplanner-business/src/main/resources/org/navalplanner/business/orders/entities/Orders.hbm.xml b/navalplanner-business/src/main/resources/org/navalplanner/business/orders/entities/Orders.hbm.xml
index af972fbc7..855e52064 100644
--- a/navalplanner-business/src/main/resources/org/navalplanner/business/orders/entities/Orders.hbm.xml
+++ b/navalplanner-business/src/main/resources/org/navalplanner/business/orders/entities/Orders.hbm.xml
@@ -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">
diff --git a/navalplanner-business/src/main/resources/org/navalplanner/business/planner/entities/ResourceAllocations.hbm.xml b/navalplanner-business/src/main/resources/org/navalplanner/business/planner/entities/ResourceAllocations.hbm.xml
index 425939d21..768fb088d 100644
--- a/navalplanner-business/src/main/resources/org/navalplanner/business/planner/entities/ResourceAllocations.hbm.xml
+++ b/navalplanner-business/src/main/resources/org/navalplanner/business/planner/entities/ResourceAllocations.hbm.xml
@@ -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>
diff --git a/navalplanner-business/src/main/resources/org/navalplanner/business/resources/entities/Resources.hbm.xml b/navalplanner-business/src/main/resources/org/navalplanner/business/resources/entities/Resources.hbm.xml
index 2402837bb..658c37858 100644
--- a/navalplanner-business/src/main/resources/org/navalplanner/business/resources/entities/Resources.hbm.xml
+++ b/navalplanner-business/src/main/resources/org/navalplanner/business/resources/entities/Resources.hbm.xml
@@ -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"
diff --git a/navalplanner-business/src/test/java/org/navalplanner/business/test/advance/entities/AdvanceAssigmentTest.java b/navalplanner-business/src/test/java/org/navalplanner/business/test/advance/entities/AdvanceAssignmentTest.java
similarity index 68%
rename from navalplanner-business/src/test/java/org/navalplanner/business/test/advance/entities/AdvanceAssigmentTest.java
rename to navalplanner-business/src/test/java/org/navalplanner/business/test/advance/entities/AdvanceAssignmentTest.java
index 9a255c8ed..6efb864dd 100644
--- a/navalplanner-business/src/test/java/org/navalplanner/business/test/advance/entities/AdvanceAssigmentTest.java
+++ b/navalplanner-business/src/test/java/org/navalplanner/business/test/advance/entities/AdvanceAssignmentTest.java
@@ -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);
     }
 
diff --git a/navalplanner-business/src/test/java/org/navalplanner/business/test/orders/entities/AddAdvanceAssigmentsToOrderElementTest.java b/navalplanner-business/src/test/java/org/navalplanner/business/test/orders/entities/AddAdvanceAssignmentsToOrderElementTest.java
similarity index 62%
rename from navalplanner-business/src/test/java/org/navalplanner/business/test/orders/entities/AddAdvanceAssigmentsToOrderElementTest.java
rename to navalplanner-business/src/test/java/org/navalplanner/business/test/orders/entities/AddAdvanceAssignmentsToOrderElementTest.java
index afea11c04..1b0e86c1c 100644
--- a/navalplanner-business/src/test/java/org/navalplanner/business/test/orders/entities/AddAdvanceAssigmentsToOrderElementTest.java
+++ b/navalplanner-business/src/test/java/org/navalplanner/business/test/orders/entities/AddAdvanceAssignmentsToOrderElementTest.java
@@ -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) {
diff --git a/navalplanner-business/src/test/java/org/navalplanner/business/test/orders/entities/OrderElementTest.java b/navalplanner-business/src/test/java/org/navalplanner/business/test/orders/entities/OrderElementTest.java
index 662b6366e..30b171d58 100644
--- a/navalplanner-business/src/test/java/org/navalplanner/business/test/orders/entities/OrderElementTest.java
+++ b/navalplanner-business/src/test/java/org/navalplanner/business/test/orders/entities/OrderElementTest.java
@@ -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)));
     }
 
diff --git a/navalplanner-business/src/test/java/org/navalplanner/business/test/planner/daos/AssigmentFunctionDAOTest.java b/navalplanner-business/src/test/java/org/navalplanner/business/test/planner/daos/AssigmentFunctionDAOTest.java
deleted file mode 100644
index 6e0784bf6..000000000
--- a/navalplanner-business/src/test/java/org/navalplanner/business/test/planner/daos/AssigmentFunctionDAOTest.java
+++ /dev/null
@@ -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());
-    }
-}
diff --git a/navalplanner-business/src/test/java/org/navalplanner/business/test/planner/daos/AssignmentFunctionDAOTest.java b/navalplanner-business/src/test/java/org/navalplanner/business/test/planner/daos/AssignmentFunctionDAOTest.java
new file mode 100644
index 000000000..e26b2b97b
--- /dev/null
+++ b/navalplanner-business/src/test/java/org/navalplanner/business/test/planner/daos/AssignmentFunctionDAOTest.java
@@ -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());
+    }
+}
diff --git a/navalplanner-business/src/test/java/org/navalplanner/business/test/planner/daos/DayAssigmentDAOTest.java b/navalplanner-business/src/test/java/org/navalplanner/business/test/planner/daos/DayAssignmentDAOTest.java
similarity index 50%
rename from navalplanner-business/src/test/java/org/navalplanner/business/test/planner/daos/DayAssigmentDAOTest.java
rename to navalplanner-business/src/test/java/org/navalplanner/business/test/planner/daos/DayAssignmentDAOTest.java
index c9e52d94e..baf8e2cbf 100644
--- a/navalplanner-business/src/test/java/org/navalplanner/business/test/planner/daos/DayAssigmentDAOTest.java
+++ b/navalplanner-business/src/test/java/org/navalplanner/business/test/planner/daos/DayAssignmentDAOTest.java
@@ -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());
     }
 }
diff --git a/navalplanner-business/src/test/java/org/navalplanner/business/test/planner/entities/DayAssigmentMatchers.java b/navalplanner-business/src/test/java/org/navalplanner/business/test/planner/entities/DayAssignmentMatchers.java
similarity index 63%
rename from navalplanner-business/src/test/java/org/navalplanner/business/test/planner/entities/DayAssigmentMatchers.java
rename to navalplanner-business/src/test/java/org/navalplanner/business/test/planner/entities/DayAssignmentMatchers.java
index 3d43a2649..76a9fb82f 100644
--- a/navalplanner-business/src/test/java/org/navalplanner/business/test/planner/entities/DayAssigmentMatchers.java
+++ b/navalplanner-business/src/test/java/org/navalplanner/business/test/planner/entities/DayAssignmentMatchers.java
@@ -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;
diff --git a/navalplanner-business/src/test/java/org/navalplanner/business/test/planner/entities/GenericResourceAllocationTest.java b/navalplanner-business/src/test/java/org/navalplanner/business/test/planner/entities/GenericResourceAllocationTest.java
index ee12010ea..208b9e874 100644
--- a/navalplanner-business/src/test/java/org/navalplanner/business/test/planner/entities/GenericResourceAllocationTest.java
+++ b/navalplanner-business/src/test/java/org/navalplanner/business/test/planner/entities/GenericResourceAllocationTest.java
@@ -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) {
diff --git a/navalplanner-business/src/test/java/org/navalplanner/business/test/planner/entities/SpecificResourceAllocationTest.java b/navalplanner-business/src/test/java/org/navalplanner/business/test/planner/entities/SpecificResourceAllocationTest.java
index 27983603d..cd29bdd5d 100644
--- a/navalplanner-business/src/test/java/org/navalplanner/business/test/planner/entities/SpecificResourceAllocationTest.java
+++ b/navalplanner-business/src/test/java/org/navalplanner/business/test/planner/entities/SpecificResourceAllocationTest.java
@@ -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));
     }
 
 }
diff --git a/navalplanner-business/src/test/java/org/navalplanner/business/test/resources/entities/ResourceTest.java b/navalplanner-business/src/test/java/org/navalplanner/business/test/resources/entities/ResourceTest.java
index eacc590a7..3fce25e34 100644
--- a/navalplanner-business/src/test/java/org/navalplanner/business/test/resources/entities/ResourceTest.java
+++ b/navalplanner-business/src/test/java/org/navalplanner/business/test/resources/entities/ResourceTest.java
@@ -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() {
diff --git a/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/IManageOrderElementAdvancesModel.java b/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/IManageOrderElementAdvancesModel.java
index 304155782..e0354d724 100644
--- a/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/IManageOrderElementAdvancesModel.java
+++ b/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/IManageOrderElementAdvancesModel.java
@@ -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(
diff --git a/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/ManageOrderElementAdvancesController.java b/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/ManageOrderElementAdvancesController.java
index 4776be225..f5369b6e8 100644
--- a/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/ManageOrderElementAdvancesController.java
+++ b/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/ManageOrderElementAdvancesController.java
@@ -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"));
                         }
                     }
                 }
diff --git a/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/ManageOrderElementAdvancesModel.java b/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/ManageOrderElementAdvancesModel.java
index fc45ed009..a8189f642 100644
--- a/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/ManageOrderElementAdvancesModel.java
+++ b/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/ManageOrderElementAdvancesModel.java
@@ -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;
diff --git a/navalplanner-webapp/src/main/java/org/navalplanner/web/planner/SaveCommand.java b/navalplanner-webapp/src/main/java/org/navalplanner/web/planner/SaveCommand.java
index 73702ea04..42ca9480c 100644
--- a/navalplanner-webapp/src/main/java/org/navalplanner/web/planner/SaveCommand.java
+++ b/navalplanner-webapp/src/main/java/org/navalplanner/web/planner/SaveCommand.java
@@ -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();
                     }
                 }
             }
diff --git a/navalplanner-webapp/src/main/webapp/orders/_listOrderElementAdvances.zul b/navalplanner-webapp/src/main/webapp/orders/_listOrderElementAdvances.zul
index b676a43bc..92ab7c091 100644
--- a/navalplanner-webapp/src/main/webapp/orders/_listOrderElementAdvances.zul
+++ b/navalplanner-webapp/src/main/webapp/orders/_listOrderElementAdvances.zul
@@ -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">
diff --git a/navalplanner-webapp/src/main/webapp/planner/main.zul b/navalplanner-webapp/src/main/webapp/planner/main.zul
index 543b19884..c7d9869ed 100644
--- a/navalplanner-webapp/src/main/webapp/planner/main.zul
+++ b/navalplanner-webapp/src/main/webapp/planner/main.zul
@@ -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}">
diff --git a/navalplanner-webapp/src/main/webapp/planner/order.zul b/navalplanner-webapp/src/main/webapp/planner/order.zul
index 49dfa1d7b..77b61cb1b 100644
--- a/navalplanner-webapp/src/main/webapp/planner/order.zul
+++ b/navalplanner-webapp/src/main/webapp/planner/order.zul
@@ -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}">
diff --git a/navalplanner-webapp/src/main/webapp/planner/resources_use.zul b/navalplanner-webapp/src/main/webapp/planner/resources_use.zul
index 3a7bc99b9..3c8630da2 100644
--- a/navalplanner-webapp/src/main/webapp/planner/resources_use.zul
+++ b/navalplanner-webapp/src/main/webapp/planner/resources_use.zul
@@ -8,7 +8,7 @@
 <zk>
 
     <resourcesLoadPanel id="planner" self="@{define(content)}">
-        <div id="idContextMenuTaskAssigment"></div>
+        <div id="idContextMenuTaskAssignment"></div>
     </resourcesLoadPanel>
 
 </zk>