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

ItEr33S11CUConfiguracionMaquinasItEr32S14: Formatting code, documenting and some fixings.

Browse source
This commit is contained in:
Javier Moran Rua 2009-11-07 22:41:35 +01:00
parent 7d3e888ff3
commit 0c8bacef83
6 changed files with 215 additions and 126 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
navalplanner-business/src/main/java/org/navalplanner/business/resources/entities/Machine.java
View file

@ -42,7 +42,6 @@ public class Machine extends Resource {
this.code = code;
this.name = name;
this.description = description;
getConfigurationUnits();
}
public static Machine create() {

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

@ -126,7 +126,7 @@
<key column="id" not-null="false" />
<many-to-many class="org.navalplanner.business.resources.entities.Criterion" column="CRITERION_ID"/>
</set>
<set inverse="true" name="workerAssignments" cascade="all-delete-orphan">
<set inverse="true" name="workerAssignments" cascade="all-delete-orphan">
<key column="configuration_id" />
<one-to-many
class="MachineWorkerAssignment" />
@ -144,7 +144,7 @@
<version name="version" access="property" type="long" />
<property access="field" name="startDate" />
<property access="field" name="finishDate"/>
<many-to-one access="field" name="machineWorkersConfigurationUnit" column="configuration_id" class="MachineWorkersConfigurationUnit" not-null="true"/>
<many-to-one access="field" name="machineWorkersConfigurationUnit" class="MachineWorkersConfigurationUnit" column="configuration_id" not-null="true"/>
<many-to-one access="field" name="worker" class="Worker" column="worker_id" />
</class>

61
navalplanner-webapp/src/main/java/org/navalplanner/web/resources/machine/IMachineModel.java
View file

@ -21,35 +21,62 @@
package org.navalplanner.web.resources.machine;
import java.util.List;
import org.navalplanner.business.calendars.entities.BaseCalendar;
import org.navalplanner.business.calendars.entities.ResourceCalendar;
import org.navalplanner.business.common.exceptions.ValidationException;
import org.navalplanner.business.resources.entities.Criterion;
import org.navalplanner.business.resources.entities.Machine;
import org.navalplanner.business.resources.entities.MachineWorkersConfigurationUnit;
/*
* This interface contains the operations to create/edit a machine.
*
* Conversation state: the Machine instance and associated entities.
* The MachineWorkersConfigurationUnit set of the machine,
* the MachineWorkerAssigments of each MachineWorkersConfigurationUnit instance,
* the Criterion set required by each MachineWorkersConfigurationUnit instance,
* the calendar associated with the Machine instance
*
* <strong>Conversation protocol:</strong>
*
* <strong>Initial steps:</strong>
* <code>initCreate</code>
* <code>initEdit</code>
*
* <strong>Intermediate conversational steps:</strong>
* <code>getConfigurationUnitsOfMachine</code>
* <code>setCalendarOfMachine</code>
* <code>setCalendarOfMachine</code>
*
* <strong>Final conversational step:</strong>
* <code>confirmSave()</code>
*
* <strong>Not conversational steps:</strong>
* <code>getMachines()</code>
* <code>getBaseCalendars()</code>
*
* @author Diego Pino Garcia <dpino@igalia.com>
* @author Javier Moran Rua <jmoran@igalia.com>
*/
public interface IMachineModel {
void confirmSave() throws ValidationException;
List<BaseCalendar> getBaseCalendars();
ResourceCalendar getCalendar();
Machine getMachine();
List<Machine> getMachines();
List<MachineWorkersConfigurationUnit> getConfigurationUnits();
// Initial conversational steps
void initCreate();
void initEdit(Machine machine);
void setCalendar(ResourceCalendar resourceCalendar);
}
// Intermediate conversation steps
Machine getMachine();
ResourceCalendar getCalendarOfMachine();
List<MachineWorkersConfigurationUnit> getConfigurationUnitsOfMachine();
void setCalendarOfMachine(ResourceCalendar resourceCalendar);
void addWorkerAssigmentToConfigurationUnit(MachineWorkersConfigurationUnit
machineWorkersConfigurationUnit);
void addCriterionRequirementToConfigurationUnit(
MachineWorkersConfigurationUnit criterion);
// Final conversational step
void confirmSave() throws ValidationException;
// Non conversational methods
List<Machine> getMachines();
List<BaseCalendar> getBaseCalendars();
}

12
navalplanner-webapp/src/main/java/org/navalplanner/web/resources/machine/MachineCRUDController.java
View file

@ -173,7 +173,7 @@ public class MachineCRUDController extends GenericForwardComposer {
}
updateCalendarController();
resourceCalendarModel.initEdit(machineModel.getCalendar());
resourceCalendarModel.initEdit(machineModel.getCalendarOfMachine());
try {
baseCalendarEditionController.doAfterCompose(editCalendarWindow);
} catch (Exception e) {
@ -275,7 +275,7 @@ public class MachineCRUDController extends GenericForwardComposer {
}
updateCalendarController();
machineModel.setCalendar((ResourceCalendar) resourceCalendarModel
machineModel.setCalendarOfMachine((ResourceCalendar) resourceCalendarModel
.getBaseCalendar());
try {
baseCalendarEditionController.doAfterCompose(editCalendarWindow);
@ -311,7 +311,7 @@ public class MachineCRUDController extends GenericForwardComposer {
@Override
public void goToList() {
machineModel
.setCalendar((ResourceCalendar) resourceCalendarModel
.setCalendarOfMachine((ResourceCalendar) resourceCalendarModel
.getBaseCalendar());
reloadWindow();
}
@ -319,14 +319,14 @@ public class MachineCRUDController extends GenericForwardComposer {
@Override
public void cancel() {
resourceCalendarModel.cancel();
machineModel.setCalendar(null);
machineModel.setCalendarOfMachine(null);
reloadWindow();
}
@Override
public void save() {
machineModel
.setCalendar((ResourceCalendar) resourceCalendarModel
.setCalendarOfMachine((ResourceCalendar) resourceCalendarModel
.getBaseCalendar());
reloadWindow();
}
@ -342,7 +342,7 @@ public class MachineCRUDController extends GenericForwardComposer {
}
public boolean isCalendarNull() {
return (machineModel.getCalendar() == null);
return (machineModel.getCalendarOfMachine() == null);
}
public boolean isCalendarNotNull() {

26
navalplanner-webapp/src/main/java/org/navalplanner/web/resources/machine/MachineConfigurationController.java
View file

@ -100,48 +100,32 @@ public class MachineConfigurationController extends GenericForwardComposer {
}
public List<MachineWorkersConfigurationUnit> getConfigurationUnits() {
return this.machineModel.getConfigurationUnits();
return this.machineModel.getConfigurationUnitsOfMachine();
}
public List<MachineWorkerAssignment> getWorkerAssignments() {
// Need to specify concrete unit
MachineWorkersConfigurationUnit unit = (MachineWorkersConfigurationUnit) this.machineModel
.getConfigurationUnits().iterator().next();
.getConfigurationUnitsOfMachine().iterator().next();
return (List<MachineWorkerAssignment>) unit.getWorkerAssignments();
}
public List<Criterion> getRequiredCriterions() {
// Need to specify concrete unit
MachineWorkersConfigurationUnit unit = (MachineWorkersConfigurationUnit) this.machineModel
.getConfigurationUnits().iterator().next();
.getConfigurationUnitsOfMachine().iterator().next();
return (List<Criterion>) unit.getRequiredCriterions();
}
@Transactional(readOnly = true)
public void addValidMachineWorkerAssignments(
MachineWorkersConfigurationUnit unit) {
Worker worker = null;
// Pending to add selected worker from autocomplete component
worker = workerDAO.getWorkers().iterator().next();
unit.addNewWorkerAssignment(worker);
}
public void addValidCriterionRequirement(
MachineWorkersConfigurationUnit unit) {
// Pending to add selected criterion from autocomplete component
Criterion criterion = criterionDAO.getAll().iterator().next();
unit.addRequiredCriterion(criterion);
}
public void addWorkerAssignment(MachineWorkersConfigurationUnit unit,
Component c) {
addValidMachineWorkerAssignments(unit);
machineModel.addWorkerAssigmentToConfigurationUnit(unit);
Util.reloadBindings(c.getNextSibling());
}
public void addCriterionRequirement(MachineWorkersConfigurationUnit unit,
Component c) {
addValidCriterionRequirement(unit);
machineModel.addCriterionRequirementToConfigurationUnit(unit);
Util.reloadBindings(c.getNextSibling());
}

237
navalplanner-webapp/src/main/java/org/navalplanner/web/resources/machine/MachineModel.java
View file

@ -21,24 +21,36 @@
package org.navalplanner.web.resources.machine;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.apache.commons.lang.Validate;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.validator.ClassValidator;
import org.hibernate.validator.InvalidValue;
import org.hsqldb.lib.Collection;
import org.navalplanner.business.calendars.daos.IBaseCalendarDAO;
import org.navalplanner.business.calendars.entities.BaseCalendar;
import org.navalplanner.business.calendars.entities.ResourceCalendar;
import org.navalplanner.business.common.exceptions.InstanceNotFoundException;
import org.navalplanner.business.common.exceptions.ValidationException;
import org.navalplanner.business.resources.daos.ICriterionDAO;
import org.navalplanner.business.resources.daos.ICriterionTypeDAO;
import org.navalplanner.business.resources.daos.IMachineDAO;
import org.navalplanner.business.resources.daos.IResourceDAO;
import org.navalplanner.business.resources.daos.IWorkerDAO;
import org.navalplanner.business.resources.entities.Criterion;
import org.navalplanner.business.resources.entities.CriterionSatisfaction;
import org.navalplanner.business.resources.entities.CriterionType;
import org.navalplanner.business.resources.entities.Machine;
import org.navalplanner.business.resources.entities.MachineWorkerAssignment;
import org.navalplanner.business.resources.entities.MachineWorkersConfigurationUnit;
import org.navalplanner.business.resources.entities.ResourceEnum;
import org.navalplanner.business.resources.entities.Worker;
import org.navalplanner.web.calendars.IBaseCalendarModel;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
@ -49,21 +61,39 @@ import org.springframework.transaction.annotation.Transactional;
/**
* @author Diego Pino Garcia <dpino@igalia.com>
* @author Javier Moran Rua <jmoran@igalia.com>
*/
@Service
@Scope(BeanDefinition.SCOPE_PROTOTYPE)
public class MachineModel implements IMachineModel {
private static Log LOG = LogFactory.getLog(MachineModel.class);
/*
* State field. Machine is the root of the aggregate
* for holding the state. Includes:
*
* the Machine instance and associated entities.
* The MachineWorkersConfigurationUnit set of the machine,
* the MachineWorkerAssigments of each MachineWorkersConfigurationUnit instance,
* the Criterion set required by each MachineWorkersConfigurationUnit instance,
* the calendar associated with the Machine instance
*
*/
private Machine machine;
private Map<Long,Criterion> criterions = new HashMap<Long,Criterion>();
private Map<Long,Worker> workers = new HashMap<Long,Worker>();
@Autowired
private IResourceDAO resourceDAO;
@Autowired
private IMachineDAO machineDAO;
@Autowired
private IBaseCalendarDAO baseCalendarDAO;
private Machine machine;
@Autowired
private ICriterionDAO criterionDAO;
@Autowired
private ICriterionTypeDAO criterionTypeDAO;
@Autowired
private IWorkerDAO workerDAO;
private ClassValidator<Machine> validator = new ClassValidator<Machine>(
Machine.class);
@ -72,6 +102,30 @@ public class MachineModel implements IMachineModel {
@Qualifier("subclass")
private IBaseCalendarModel baseCalendarModel;
private void reattachCriterionsCache() {
for (Criterion each: criterions.values()) {
criterionDAO.reattachUnmodifiedEntity(each);
}
}
private void reattachWorkersCache() {
for (Worker each: workers.values()) {
workerDAO.reattachUnmodifiedEntity(each);
}
}
private void insertInCriterionsCacheIfNotExist(Criterion criterion) {
if (!criterions.containsValue(criterion)) {
criterions.put(criterion.getId(), criterion);
}
}
private void insertInWorkersCacheIfNotExist(Worker worker) {
if (!workers.containsValue(worker)) {
workers.put(worker.getId(), worker);
}
}
@Override
public void initCreate() {
machine = Machine.create();
@ -79,8 +133,54 @@ public class MachineModel implements IMachineModel {
@Override
@Transactional(readOnly = true)
public List<Machine> getMachines() {
return machineDAO.getAll();
public void initEdit(Machine machine) {
Validate.notNull(machine);
try {
this.machine = (Machine) resourceDAO.find(machine.getId());
loadDepedentEntities();
} catch (InstanceNotFoundException e) {
LOG.error("Machine with id " + machine.getId()
+ " not found", e);
throw new RuntimeException();
}
}
private void loadDepedentEntities() {
reattachCriterionsCache();
reattachWorkersCache();
loadCriterionSatisfactions();
loadConfigurationUnits();
}
private void loadCriterionSatisfactions() {
for (CriterionSatisfaction each: machine.getCriterionSatisfactions()) {
each.getStartDate();
each.getCriterion().getName();
insertInCriterionsCacheIfNotExist(each.getCriterion());
}
}
private void loadConfigurationUnits() {
for (MachineWorkersConfigurationUnit each : machine.getConfigurationUnits()) {
each.getName();
loadRequiredCriterionsOf(each);
loadMachineWorkersAssignmentsOf(each);
}
}
private void loadRequiredCriterionsOf(MachineWorkersConfigurationUnit configurationUnit) {
for (Criterion each: configurationUnit.getRequiredCriterions()) {
each.getName();
insertInCriterionsCacheIfNotExist(each);
}
}
private void loadMachineWorkersAssignmentsOf(MachineWorkersConfigurationUnit configurationUnit) {
for (MachineWorkerAssignment each: configurationUnit.getWorkerAssignments()) {
each.getStartDate();
each.getWorker().getName();
insertInWorkersCacheIfNotExist(each.getWorker());
}
}
@Override
@ -90,13 +190,61 @@ public class MachineModel implements IMachineModel {
@Override
@Transactional(readOnly = true)
public List<MachineWorkersConfigurationUnit> getConfigurationUnits() {
public List<MachineWorkersConfigurationUnit> getConfigurationUnitsOfMachine() {
ArrayList<MachineWorkersConfigurationUnit> elements = new ArrayList<MachineWorkersConfigurationUnit>();
if ( machine != null )
elements.addAll(machine.getConfigurationUnits());
return elements;
}
@Override
public void setCalendarOfMachine(ResourceCalendar resourceCalendar) {
if (machine != null) {
machine.setCalendar(resourceCalendar);
}
}
@Override
public ResourceCalendar getCalendarOfMachine() {
return (machine != null) ? machine.getCalendar() : null;
}
@Transactional(readOnly=true)
@Override
public void addWorkerAssigmentToConfigurationUnit(
MachineWorkersConfigurationUnit unit) {
// TODO: Modify method to add the WorkerAssigment to add
Worker worker = workerDAO.getWorkers().iterator().next();
for (MachineWorkersConfigurationUnit each:
machine.getConfigurationUnits()) {
if (each == unit) {
each.addNewWorkerAssignment(worker);
}
}
}
@Transactional(readOnly=true)
@Override
public void addCriterionRequirementToConfigurationUnit(
MachineWorkersConfigurationUnit unit) {
// TODO: Modify method to add the criterion to add as parameter
HashSet<ResourceEnum> appliableToMachine =
new HashSet<ResourceEnum>();
appliableToMachine.add(ResourceEnum.MACHINE);
appliableToMachine.add(ResourceEnum.RESOURCE);
boolean stop = false;
for (CriterionType each:
criterionTypeDAO.getCriterionTypesByResources(appliableToMachine)) {
for (Criterion eachCriterion: each.getCriterions()) {
unit.addRequiredCriterion(eachCriterion);
stop = true;
break;
}
if (stop) break;
}
}
@Override
@Transactional
public void confirmSave() throws ValidationException {
@ -110,68 +258,6 @@ public class MachineModel implements IMachineModel {
resourceDAO.save(machine);
}
@Override
@Transactional(readOnly = true)
public void initEdit(Machine machine) {
Validate.notNull(machine);
this.machine = getFromDB(machine);
}
private Machine getFromDB(Machine machine) {
return getFromDB(machine.getId());
}
private Machine getFromDB(Long id) {
try {
Machine machine = (Machine) resourceDAO.find(id);
initializeCriterionsSatisfactions(machine
.getCriterionSatisfactions());
initializeConfigurationUnits(machine.getConfigurationUnits());
return machine;
} catch (InstanceNotFoundException e) {
throw new RuntimeException(e);
}
}
private void initializeCriterionsSatisfactions(
Set<CriterionSatisfaction> criterionSatisfactions) {
for (CriterionSatisfaction criterionSatisfaction : criterionSatisfactions) {
initializeCriterionSatisfaction(criterionSatisfaction);
}
}
private void initializeCriterionSatisfaction(
CriterionSatisfaction criterionSatisfaction) {
initializeCriterion(criterionSatisfaction.getCriterion());
}
private void initializeCriterion(Criterion criterion) {
criterion.getName();
criterion.getName();
if (criterion.getParent() != null) {
criterion.getParent().getName();
}
}
private void initializeConfigurationUnits(
Set<MachineWorkersConfigurationUnit> configurationUnits) {
for (MachineWorkersConfigurationUnit configurationUnit : configurationUnits) {
initializeConfigurationUnit(configurationUnit);
}
}
private void initializeConfigurationUnit(
MachineWorkersConfigurationUnit configurationUnit) {
configurationUnit.getName();
for (Criterion criterion : configurationUnit.getRequiredCriterions()) {
criterion.getName();
}
for (MachineWorkerAssignment assignment : configurationUnit
.getWorkerAssignments()) {
assignment.getWorker().getName();
}
}
@Override
@Transactional(readOnly = true)
public List<BaseCalendar> getBaseCalendars() {
@ -179,15 +265,8 @@ public class MachineModel implements IMachineModel {
}
@Override
public void setCalendar(ResourceCalendar resourceCalendar) {
if (machine != null) {
machine.setCalendar(resourceCalendar);
}
@Transactional(readOnly = true)
public List<Machine> getMachines() {
return machineDAO.getAll();
}
@Override
public ResourceCalendar getCalendar() {
return (machine != null) ? machine.getCalendar() : null;
}
}