Menu
▾
▴
[Cse-ip-svn-commits] SF.net SVN: cse-ip:[167] trunk/cse-ip/sc-cdmm/src
|
From: <ro...@us...> - 2009-04-23 14:49:51
|
Revision: 167
http://cse-ip.svn.sourceforge.net/cse-ip/?rev=167&view=rev
Author: roekens
Date: 2009-04-23 14:49:13 +0000 (Thu, 23 Apr 2009)
Log Message:
-----------
- reimplementation of createOrUpdate methods
- testing
- bugfixes
Modified Paths:
--------------
trunk/cse-ip/sc-cdmm/src/main/java/de/campussource/cse/cdmm/DataModelManagerBean.java
trunk/cse-ip/sc-cdmm/src/main/java/de/campussource/cse/cdmm/dao/DAOJPA.java
trunk/cse-ip/sc-cdmm/src/test/java/de/campussource/cse/cdmm/DataModelManagerBeanTest.java
Modified: trunk/cse-ip/sc-cdmm/src/main/java/de/campussource/cse/cdmm/DataModelManagerBean.java
===================================================================
--- trunk/cse-ip/sc-cdmm/src/main/java/de/campussource/cse/cdmm/DataModelManagerBean.java 2009-04-23 13:28:38 UTC (rev 166)
+++ trunk/cse-ip/sc-cdmm/src/main/java/de/campussource/cse/cdmm/DataModelManagerBean.java 2009-04-23 14:49:13 UTC (rev 167)
@@ -53,132 +53,143 @@
.getLogger(DataModelManagerBean.class);
@Override
- @WebMethod(action = "createOrUpdateCategory")
- @WebResult(name = "EventMessages")
- public List<EventMessage> createOrUpdateCategory(
- @WebParam(name = "CategoryMessage") CategoryMessage categoryMessage) {
-
- // init eventMessageList
- List<EventMessage> events = new ArrayList<EventMessage>();
- // get state of given object in persistence
- State state = null;
- Category loadedCategory = null;
- try {
- loadedCategory = categoryDao.find(categoryMessage.getCategory()
- .getId());
- state = loadedCategory.getState();
- } catch (ServiceComponentException e1) {
- logger.debug(e1);
- logger.debug(e1.getMessage());
- logger.debug(e1);
- logger.debug(e1.getMessage()); // do nothing
- }
- // check if event time is before entity state time
- if (loadedCategory == null
- || loadedCategory.getDate().after(
- categoryMessage.getEventTime())) {
- return events;
- }
-
- // handle different inputEvents
- if (categoryMessage.getInputEvent() == InputEventType.CREATE_UPDATE) {
- // handle different states of entity
- EventMessage eventMessage = new EventMessage();
- Category category = categoryMessage.getCategory();
- category.setState(State.EXISTS);
- category.setDate(categoryMessage.getEventTime());
- eventMessage.setEntity(category);
- try {
- categoryDao.persist(category);
- } catch (ServiceComponentException e) {
- // TODO handle me
- }
- if (state == State.EXISTS) {
- eventMessage.setOutputEvent(OutputEventType.UPDATE);
- } else {
- eventMessage.setOutputEvent(OutputEventType.CREATE);
- }
- eventMessage.setEventTime(new Date());
- events.add(eventMessage);
-
- createReferences(category);
-
- } else if (categoryMessage.getInputEvent() == InputEventType.DELETE) {
- return deleteCategory(categoryMessage);
- } else if (categoryMessage.getInputEvent() == InputEventType.CREATE_BY_REFERENCE) {
- Category knownCategory = categoryMessage.getCategory();
- knownCategory.setState(State.KNOWN);
- try {
- categoryDao.persist(knownCategory);
- } catch (ServiceComponentException e) {
- // TODO handle me
- }
- }
- return events;
- }
-
- @Override
@WebMethod(action = "createOrUpdateCourse")
@WebResult(name = "EventMessages")
public List<EventMessage> createOrUpdateCourse(
@WebParam(name = "CourseMessage") CourseMessage courseMessage) {
// init eventMessageList
List<EventMessage> events = new ArrayList<EventMessage>();
- // get state of given object in persistence
- State state = null;
+
Course loadedCourse = null;
+ Course newCourse = courseMessage.getCourse();
+ newCourse.setDate(courseMessage.getEventTime());
+ newCourse.setState(State.EXISTS);
try {
loadedCourse = courseDao.find(courseMessage.getCourse().getId());
- state = loadedCourse.getState();
} catch (ServiceComponentException e1) {
logger.debug(e1);
logger.debug(e1.getMessage()); // do nothing
}
- // check if event time is before entity state time
- if (loadedCourse == null
- || loadedCourse.getDate().after(courseMessage.getEventTime())) {
- return events;
- }
-
- // handle different inputEvents
- if (courseMessage.getInputEvent() == InputEventType.CREATE_UPDATE) {
- // handle different states of entity
- EventMessage eventMessage = new EventMessage();
- Course course = courseMessage.getCourse();
- course.setState(State.EXISTS);
- course.setDate(courseMessage.getEventTime());
- eventMessage.setEntity(course);
- try {
- courseDao.persist(course);
+
+ //state = NOTEXISTS
+ if (loadedCourse==null){
+ try {
+ events.add(persistCourse(newCourse, OutputEventType.CREATE));
+ return events;
} catch (ServiceComponentException e) {
- // TODO handle me
+ //TODO handle me
+ logger.debug(e.getStackTrace());
+ return null;
}
- if (state == State.EXISTS) {
- eventMessage.setOutputEvent(OutputEventType.UPDATE);
- } else {
- eventMessage.setOutputEvent(OutputEventType.CREATE);
+ } //state = KNOWN / EXISTS or DELETED
+ else {
+ // state==KNOWN
+ if (loadedCourse.getState()==State.KNOWN){
+ try {
+ events.add(persistCourse(newCourse, OutputEventType.CREATE));
+ //FIXME add events for associated objects
+ return events;
+ } catch (ServiceComponentException e) {
+ //TODO handle me
+ logger.debug(e.getStackTrace());
+ return null;
+ }
+ } //state = EXISTS or DELETED
+ else {
+ //check if inputEvent has to be handled
+ if (!courseMessage.getEventTime().after(loadedCourse.getDate())) {
+ return events;
+ }
+ if (loadedCourse.getState()==State.DELETED){
+ try {
+ events.add(persistCourse(newCourse, OutputEventType.CREATE));
+ } catch (ServiceComponentException e) {
+ //TODO handle me
+ logger.debug(e.getStackTrace());
+ return null;
+ }
+ return events;
+ } else if (loadedCourse.getState()==State.EXISTS){
+ try {
+ events.add(persistCourse(newCourse, OutputEventType.UPDATE));
+ } catch (ServiceComponentException e) {
+ //TODO handle me
+ logger.debug(e.getStackTrace());
+ return null;
+ }
+ return events;
+ }
}
- eventMessage.setEventTime(new Date());
- events.add(eventMessage);
-
- createReferences(course);
-
- } else if (courseMessage.getInputEvent() == InputEventType.DELETE) {
- return deleteCourse(courseMessage);
- } else if (courseMessage.getInputEvent() == InputEventType.CREATE_BY_REFERENCE) {
- Course knownCourse = courseMessage.getCourse();
- knownCourse.setState(State.KNOWN);
- try {
- courseDao.persist(knownCourse);
- } catch (ServiceComponentException e) {
- logger.debug(e);
- logger.debug(e.getMessage());
- // TODO handle me
- }
}
+
return events;
}
+ private EventMessage persistCourse(Course newCourse, OutputEventType outputEvent)
+ throws ServiceComponentException {
+ courseDao.persist(newCourse);
+
+ createReferences(newCourse);
+
+ EventMessage event = new EventMessage();
+ event.setEntity(newCourse);
+ event.setEventTime(new Date());
+ event.setOutputEvent(outputEvent);
+ return event;
+ }
+
+ private EventMessage persistAccount(Account newAccount, OutputEventType outputEvent)
+ throws ServiceComponentException {
+ accountDao.persist(newAccount);
+
+ createReferences(newAccount);
+
+ EventMessage event = new EventMessage();
+ event.setEntity(newAccount);
+ event.setEventTime(new Date());
+ event.setOutputEvent(outputEvent);
+ return event;
+ }
+
+ private EventMessage persistGroup(Group newGroup, OutputEventType outputEvent)
+ throws ServiceComponentException {
+ groupDao.persist(newGroup);
+
+ createReferences(newGroup);
+
+ EventMessage event = new EventMessage();
+ event.setEntity(newGroup);
+ event.setEventTime(new Date());
+ event.setOutputEvent(outputEvent);
+ return event;
+ }
+
+ private EventMessage persistRole(Role newRole, OutputEventType outputEvent)
+ throws ServiceComponentException {
+ roleDao.persist(newRole);
+
+ createReferences(newRole);
+
+ EventMessage event = new EventMessage();
+ event.setEntity(newRole);
+ event.setEventTime(new Date());
+ event.setOutputEvent(outputEvent);
+ return event;
+ }
+
+ private EventMessage persistCategory(Category newCategory, OutputEventType outputEvent)
+ throws ServiceComponentException {
+ categoryDao.persist(newCategory);
+
+ createReferences(newCategory);
+
+ EventMessage event = new EventMessage();
+ event.setEntity(newCategory);
+ event.setEventTime(new Date());
+ event.setOutputEvent(outputEvent);
+ return event;
+ }
+
private void createReferences(Course course) {
// traverse associated objects and create them
// categories
@@ -244,6 +255,9 @@
}
private void createByReference(Category category) {
+ if (category == null){
+ return;
+ }
try {
@SuppressWarnings("unused")
Category loadedCategory = categoryDao.find(category.getId());
@@ -257,6 +271,9 @@
}
private void createByReference(Course course) {
+ if (course == null){
+ return;
+ }
try {
@SuppressWarnings("unused")
Course loadedCourse = courseDao.find(course.getId());
@@ -270,6 +287,9 @@
}
private void createByReference(Group group) {
+ if (group == null){
+ return;
+ }
try {
@SuppressWarnings("unused")
Group loadedGroup = groupDao.find(group.getId());
@@ -283,6 +303,9 @@
}
private void createByReference(Account account) {
+ if (account == null){
+ return;
+ }
try {
@SuppressWarnings("unused")
Account loadedAccount = accountDao.find(account.getId());
@@ -296,6 +319,9 @@
}
private void createByReference(Role role) {
+ if (role == null){
+ return;
+ }
try {
@SuppressWarnings("unused")
Role loadedRole = roleDao.find(role.getId());
@@ -309,36 +335,6 @@
}
@Override
- public List<EventMessage> deleteCategory(CategoryMessage categoryMessage) {
- // init eventMessageList
- List<EventMessage> events = new ArrayList<EventMessage>();
- // get state of given object in persistence
- Category loadedCategory = null;
- try {
- loadedCategory = categoryDao.find(categoryMessage.getCategory()
- .getId());
- } catch (ServiceComponentException e1) {
- logger.debug(e1);
- logger.debug(e1.getMessage()); // do nothing
- }
- loadedCategory.setState(State.DELETED);
- try {
- categoryDao.persist(loadedCategory);
- } catch (ServiceComponentException e) {
- logger.debug(e);
- logger.debug(e.getMessage());
- // TODO handle me
- }
-
- EventMessage em = new EventMessage();
- em.setEntity(loadedCategory);
- em.setEventTime(new Date());
- em.setOutputEvent(OutputEventType.DELETE);
- events.add(em);
- return events;
- }
-
- @Override
public List<EventMessage> deleteCourse(CourseMessage courseMessage) {
// init eventMessageList
List<EventMessage> events = new ArrayList<EventMessage>();
@@ -370,63 +366,142 @@
@Override
public List<EventMessage> createOrUpdateAccount(
AccountMessage accountMessage) {
-
// init eventMessageList
List<EventMessage> events = new ArrayList<EventMessage>();
- // get state of given object in persistence
- State state = null;
+
Account loadedAccount = null;
+ Account newAccount = accountMessage.getAccount();
+ newAccount.setDate(accountMessage.getEventTime());
+ newAccount.setState(State.EXISTS);
try {
- loadedAccount = accountDao
- .find(accountMessage.getAccount().getId());
- state = loadedAccount.getState();
+ loadedAccount = accountDao.find(accountMessage.getAccount().getId());
} catch (ServiceComponentException e1) {
logger.debug(e1);
logger.debug(e1.getMessage()); // do nothing
}
- // check if event time is before entity state time
- if (loadedAccount == null
- || loadedAccount.getDate().after(accountMessage.getEventTime())) {
- return events;
- }
-
- // handle different inputEvents
- if (accountMessage.getInputEvent() == InputEventType.CREATE_UPDATE) {
- // handle different states of entity
- EventMessage eventMessage = new EventMessage();
- Account account = accountMessage.getAccount();
- account.setState(State.EXISTS);
- account.setDate(accountMessage.getEventTime());
- eventMessage.setEntity(account);
- try {
- accountDao.persist(account);
+
+ //state = NOTEXISTS
+ if (loadedAccount==null){
+ try {
+ events.add(persistAccount(newAccount, OutputEventType.CREATE));
+ return events;
} catch (ServiceComponentException e) {
- logger.debug(e);
- logger.debug(e.getMessage());
- // TODO handle me
+ //TODO handle me
+ logger.debug(e.getStackTrace());
+ return null;
}
- if (state == State.EXISTS) {
- eventMessage.setOutputEvent(OutputEventType.UPDATE);
- } else {
- eventMessage.setOutputEvent(OutputEventType.CREATE);
+ } //state = KNOWN / EXISTS or DELETED
+ else {
+ // state==KNOWN
+ if (loadedAccount.getState()==State.KNOWN){
+ try {
+ events.add(persistAccount(newAccount, OutputEventType.CREATE));
+ //FIXME add events for associated objects
+ return events;
+ } catch (ServiceComponentException e) {
+ //TODO handle me
+ logger.debug(e.getStackTrace());
+ return null;
+ }
+ } //state = EXISTS or DELETED
+ else {
+ //check if inputEvent has to be handled
+ if (!accountMessage.getEventTime().after(loadedAccount.getDate())) {
+ return events;
+ }
+ if (loadedAccount.getState()==State.DELETED){
+ try {
+ events.add(persistAccount(newAccount, OutputEventType.CREATE));
+ } catch (ServiceComponentException e) {
+ //TODO handle me
+ logger.debug(e.getStackTrace());
+ return null;
+ }
+ return events;
+ } else if (loadedAccount.getState()==State.EXISTS){
+ try {
+ events.add(persistAccount(newAccount, OutputEventType.UPDATE));
+ } catch (ServiceComponentException e) {
+ //TODO handle me
+ logger.debug(e.getStackTrace());
+ return null;
+ }
+ return events;
+ }
}
- eventMessage.setEventTime(new Date());
- events.add(eventMessage);
+ }
+ return events;
+ }
- createReferences(account);
- } else if (accountMessage.getInputEvent() == InputEventType.DELETE) {
- return deleteAccount(accountMessage);
- } else if (accountMessage.getInputEvent() == InputEventType.CREATE_BY_REFERENCE) {
- Account knownAccount = accountMessage.getAccount();
- knownAccount.setState(State.KNOWN);
- try {
- accountDao.persist(knownAccount);
+ @Override
+ public List<EventMessage> createOrUpdateCategory(
+ CategoryMessage categoryMessage) {
+ // init eventMessageList
+ List<EventMessage> events = new ArrayList<EventMessage>();
+
+ Category loadedCategory = null;
+ Category newCategory = categoryMessage.getCategory();
+ newCategory.setDate(categoryMessage.getEventTime());
+ newCategory.setState(State.EXISTS);
+ try {
+ loadedCategory = categoryDao.find(categoryMessage.getCategory().getId());
+ } catch (ServiceComponentException e1) {
+ logger.debug(e1);
+ logger.debug(e1.getMessage()); // do nothing
+ }
+
+ //state = NOTEXISTS
+ if (loadedCategory==null){
+ try {
+ events.add(persistCategory(newCategory, OutputEventType.CREATE));
+ return events;
} catch (ServiceComponentException e) {
- logger.debug(e); logger.debug(e.getMessage());
- // TODO handle me
+ //TODO handle me
+ logger.debug(e.getStackTrace());
+ return null;
}
+ } //state = KNOWN / EXISTS or DELETED
+ else {
+ // state==KNOWN
+ if (loadedCategory.getState()==State.KNOWN){
+ try {
+ events.add(persistCategory(newCategory, OutputEventType.CREATE));
+ //FIXME add events for associated objects
+ return events;
+ } catch (ServiceComponentException e) {
+ //TODO handle me
+ logger.debug(e.getStackTrace());
+ return null;
+ }
+ } //state = EXISTS or DELETED
+ else {
+ //check if inputEvent has to be handled
+ if (!categoryMessage.getEventTime().after(loadedCategory.getDate())) {
+ return events;
+ }
+ if (loadedCategory.getState()==State.DELETED){
+ try {
+ events.add(persistCategory(newCategory, OutputEventType.CREATE));
+ } catch (ServiceComponentException e) {
+ //TODO handle me
+ logger.debug(e.getStackTrace());
+ return null;
+ }
+ return events;
+ } else if (loadedCategory.getState()==State.EXISTS){
+ try {
+ events.add(persistCategory(newCategory, OutputEventType.UPDATE));
+ } catch (ServiceComponentException e) {
+ //TODO handle me
+ logger.debug(e.getStackTrace());
+ return null;
+ }
+ return events;
+ }
+ }
}
+
return events;
}
@@ -434,61 +509,69 @@
public List<EventMessage> createOrUpdateGroup(GroupMessage groupMessage) {
// init eventMessageList
List<EventMessage> events = new ArrayList<EventMessage>();
- // get state of given object in persistence
- State state = null;
+
Group loadedGroup = null;
+ Group newGroup = groupMessage.getGroup();
+ newGroup.setDate(groupMessage.getEventTime());
+ newGroup.setState(State.EXISTS);
try {
loadedGroup = groupDao.find(groupMessage.getGroup().getId());
- state = loadedGroup.getState();
} catch (ServiceComponentException e1) {
logger.debug(e1);
- logger.debug(e1.getMessage());
- // do nothing
+ logger.debug(e1.getMessage()); // do nothing
}
- // check if event time is before entity state time
- if (loadedGroup == null
- || loadedGroup.getDate().after(groupMessage.getEventTime())) {
- return events;
- }
-
- // handle different inputEvents
- if (groupMessage.getInputEvent() == InputEventType.CREATE_UPDATE) {
- // handle different states of entity
- EventMessage eventMessage = new EventMessage();
- Group group = groupMessage.getGroup();
- group.setState(State.EXISTS);
- group.setDate(groupMessage.getEventTime());
- eventMessage.setEntity(group);
- try {
- groupDao.persist(group);
+
+ //state = NOTEXISTS
+ if (loadedGroup==null){
+ try {
+ events.add(persistGroup(newGroup, OutputEventType.CREATE));
+ return events;
} catch (ServiceComponentException e) {
- logger.debug(e);
- logger.debug(e.getMessage());
- // TODO handle me
+ //TODO handle me
+ logger.debug(e.getStackTrace());
+ return null;
}
- if (state == State.EXISTS) {
- eventMessage.setOutputEvent(OutputEventType.UPDATE);
- } else {
- eventMessage.setOutputEvent(OutputEventType.CREATE);
+ } //state = KNOWN / EXISTS or DELETED
+ else {
+ // state==KNOWN
+ if (loadedGroup.getState()==State.KNOWN){
+ try {
+ events.add(persistGroup(newGroup, OutputEventType.CREATE));
+ //FIXME add events for associated objects
+ return events;
+ } catch (ServiceComponentException e) {
+ //TODO handle me
+ logger.debug(e.getStackTrace());
+ return null;
+ }
+ } //state = EXISTS or DELETED
+ else {
+ //check if inputEvent has to be handled
+ if (!groupMessage.getEventTime().after(loadedGroup.getDate())) {
+ return events;
+ }
+ if (loadedGroup.getState()==State.DELETED){
+ try {
+ events.add(persistGroup(newGroup, OutputEventType.CREATE));
+ } catch (ServiceComponentException e) {
+ //TODO handle me
+ logger.debug(e.getStackTrace());
+ return null;
+ }
+ return events;
+ } else if (loadedGroup.getState()==State.EXISTS){
+ try {
+ events.add(persistGroup(newGroup, OutputEventType.UPDATE));
+ } catch (ServiceComponentException e) {
+ //TODO handle me
+ logger.debug(e.getStackTrace());
+ return null;
+ }
+ return events;
+ }
}
- eventMessage.setEventTime(new Date());
- events.add(eventMessage);
-
- createReferences(group);
-
- } else if (groupMessage.getInputEvent() == InputEventType.DELETE) {
- return deleteGroup(groupMessage);
- } else if (groupMessage.getInputEvent() == InputEventType.CREATE_BY_REFERENCE) {
- Group knownGroup = groupMessage.getGroup();
- knownGroup.setState(State.KNOWN);
- try {
- groupDao.persist(knownGroup);
- } catch (ServiceComponentException e) {
- logger.debug(e);
- logger.debug(e.getMessage());
- // TODO handle me
- }
}
+
return events;
}
@@ -496,152 +579,94 @@
public List<EventMessage> createOrUpdateRole(RoleMessage roleMessage) {
// init eventMessageList
List<EventMessage> events = new ArrayList<EventMessage>();
- // get state of given object in persistence
- State state = null;
+
Role loadedRole = null;
+ Role newRole = roleMessage.getRole();
+ newRole.setDate(roleMessage.getEventTime());
+ newRole.setState(State.EXISTS);
try {
loadedRole = roleDao.find(roleMessage.getRole().getId());
- state = loadedRole.getState();
} catch (ServiceComponentException e1) {
logger.debug(e1);
- logger.debug(e1.getMessage());
- // do nothing
+ logger.debug(e1.getMessage()); // do nothing
}
- // check if event time is before entity state time
- if (loadedRole == null
- || loadedRole.getDate().after(roleMessage.getEventTime())) {
- return events;
- }
-
- // handle different inputEvents
- if (roleMessage.getInputEvent() == InputEventType.CREATE_UPDATE) {
- // handle different states of entity
- EventMessage eventMessage = new EventMessage();
- Role role = roleMessage.getRole();
- role.setState(State.EXISTS);
- role.setDate(roleMessage.getEventTime());
- eventMessage.setEntity(role);
- try {
- roleDao.persist(role);
+
+ //state = NOTEXISTS
+ if (loadedRole==null){
+ try {
+ events.add(persistRole(newRole, OutputEventType.CREATE));
+ return events;
} catch (ServiceComponentException e) {
- logger.debug(e);
- logger.debug(e.getMessage());
- // TODO handle me
+ //TODO handle me
+ logger.debug(e.getStackTrace());
+ return null;
}
- if (state == State.EXISTS) {
- eventMessage.setOutputEvent(OutputEventType.UPDATE);
- } else {
- eventMessage.setOutputEvent(OutputEventType.CREATE);
+ } //state = KNOWN / EXISTS or DELETED
+ else {
+ // state==KNOWN
+ if (loadedRole.getState()==State.KNOWN){
+ try {
+ events.add(persistRole(newRole, OutputEventType.CREATE));
+ //FIXME add events for associated objects
+ return events;
+ } catch (ServiceComponentException e) {
+ //TODO handle me
+ logger.debug(e.getStackTrace());
+ return null;
+ }
+ } //state = EXISTS or DELETED
+ else {
+ //check if inputEvent has to be handled
+ if (!roleMessage.getEventTime().after(loadedRole.getDate())) {
+ return events;
+ }
+ if (loadedRole.getState()==State.DELETED){
+ try {
+ events.add(persistRole(newRole, OutputEventType.CREATE));
+ } catch (ServiceComponentException e) {
+ //TODO handle me
+ logger.debug(e.getStackTrace());
+ return null;
+ }
+ return events;
+ } else if (loadedRole.getState()==State.EXISTS){
+ try {
+ events.add(persistRole(newRole, OutputEventType.UPDATE));
+ } catch (ServiceComponentException e) {
+ //TODO handle me
+ logger.debug(e.getStackTrace());
+ return null;
+ }
+ return events;
+ }
}
- eventMessage.setEventTime(new Date());
- events.add(eventMessage);
-
- createReferences(role);
-
- } else if (roleMessage.getInputEvent() == InputEventType.DELETE) {
- return deleteRole(roleMessage);
- } else if (roleMessage.getInputEvent() == InputEventType.CREATE_BY_REFERENCE) {
- Role knownRole = roleMessage.getRole();
- knownRole.setState(State.KNOWN);
- try {
- roleDao.persist(knownRole);
- } catch (ServiceComponentException e) {
- logger.debug(e);
- logger.debug(e.getMessage());
- // TODO handle me
- }
}
+
return events;
}
@Override
public List<EventMessage> deleteAccount(AccountMessage accountMessage) {
- // init eventMessageList
- List<EventMessage> events = new ArrayList<EventMessage>();
- // get state of given object in persistence
- Account loadedAccount = null;
- try {
- loadedAccount = accountDao
- .find(accountMessage.getAccount().getId());
- } catch (ServiceComponentException e1) {
- logger.debug(e1);
- logger.debug(e1.getMessage());
- // do nothing
- }
- loadedAccount.setState(State.DELETED);
- try {
- accountDao.persist(loadedAccount);
- } catch (ServiceComponentException e) {
- logger.debug(e);
- logger.debug(e.getMessage());
- // TODO handle me
- }
+ // TODO Auto-generated method stub
+ return null;
+ }
- EventMessage em = new EventMessage();
- em.setEntity(loadedAccount);
- em.setEventTime(new Date());
- em.setOutputEvent(OutputEventType.DELETE);
- events.add(em);
- return events;
+ @Override
+ public List<EventMessage> deleteCategory(CategoryMessage categoryMessage) {
+ // TODO Auto-generated method stub
+ return null;
}
@Override
public List<EventMessage> deleteGroup(GroupMessage groupMessage) {
- // init eventMessageList
- List<EventMessage> events = new ArrayList<EventMessage>();
- // get state of given object in persistence
- Group loadedGroup = null;
- try {
- loadedGroup = groupDao.find(groupMessage.getGroup().getId());
- } catch (ServiceComponentException e1) {
- logger.debug(e1);
- logger.debug(e1.getMessage());
- // do nothing
- }
- loadedGroup.setState(State.DELETED);
- try {
- groupDao.persist(loadedGroup);
- } catch (ServiceComponentException e) {
- logger.debug(e); logger.debug(e.getMessage());
- // TODO handle me
- }
-
- EventMessage em = new EventMessage();
- em.setEntity(loadedGroup);
- em.setEventTime(new Date());
- em.setOutputEvent(OutputEventType.DELETE);
- events.add(em);
- return events;
+ // TODO Auto-generated method stub
+ return null;
}
@Override
public List<EventMessage> deleteRole(RoleMessage roleMessage) {
- // init eventMessageList
- List<EventMessage> events = new ArrayList<EventMessage>();
- // get state of given object in persistence
- Role loadedRole = null;
- try {
- loadedRole = roleDao.find(roleMessage.getRole().getId());
- } catch (ServiceComponentException e1) {
- logger.debug(e1);
- logger.debug(e1.getMessage());
- // do nothing
- }
- loadedRole.setState(State.DELETED);
- try {
- roleDao.persist(loadedRole);
- } catch (ServiceComponentException e) {
- logger.debug(e);
- logger.debug(e.getMessage());
- // TODO handle me
- }
-
- EventMessage em = new EventMessage();
- em.setEntity(loadedRole);
- em.setEventTime(new Date());
- em.setOutputEvent(OutputEventType.DELETE);
- events.add(em);
- return events;
+ // TODO Auto-generated method stub
+ return null;
}
}
Modified: trunk/cse-ip/sc-cdmm/src/main/java/de/campussource/cse/cdmm/dao/DAOJPA.java
===================================================================
--- trunk/cse-ip/sc-cdmm/src/main/java/de/campussource/cse/cdmm/dao/DAOJPA.java 2009-04-23 13:28:38 UTC (rev 166)
+++ trunk/cse-ip/sc-cdmm/src/main/java/de/campussource/cse/cdmm/dao/DAOJPA.java 2009-04-23 14:49:13 UTC (rev 167)
@@ -34,6 +34,9 @@
@Override
@TransactionAttribute(TransactionAttributeType.SUPPORTS)
public E find(Serializable id) throws ServiceComponentException{
+ if (id==null){
+ return null;
+ }
E result = entityManager.find(persistentClass, id);
if (result == null){
throw new IdNotFoundException("Id: "+ id + "could not be found.");
Modified: trunk/cse-ip/sc-cdmm/src/test/java/de/campussource/cse/cdmm/DataModelManagerBeanTest.java
===================================================================
--- trunk/cse-ip/sc-cdmm/src/test/java/de/campussource/cse/cdmm/DataModelManagerBeanTest.java 2009-04-23 13:28:38 UTC (rev 166)
+++ trunk/cse-ip/sc-cdmm/src/test/java/de/campussource/cse/cdmm/DataModelManagerBeanTest.java 2009-04-23 14:49:13 UTC (rev 167)
@@ -3,9 +3,14 @@
+import java.util.Date;
+import java.util.List;
+
import org.junit.Before;
import org.junit.Test;
+import static org.junit.Assert.*;
+import de.campussource.cse.cdmm.domain.Course;
import de.campussource.cse.common.test.AbstractPersistentUnitTest;
public class DataModelManagerBeanTest extends AbstractPersistentUnitTest {
@@ -25,4 +30,23 @@
Constants constants = new Constants();
}
+ @Test
+ public void testCourseOperations(){
+ CourseMessage courseMessage = new CourseMessage();
+ courseMessage.setCourse(new Course());
+ courseMessage.setEventTime(new Date());
+ courseMessage.setInputEvent(InputEventType.CREATE_UPDATE);
+
+ List<EventMessage> events = dmm.createOrUpdateCourse(courseMessage);
+
+ assertEquals(1, events.size());
+ assertEquals(OutputEventType.CREATE, events.get(0).getOutputEvent());
+ assertNotNull(events.get(0).getEntity().getId());
+
+ courseMessage.getCourse().setId(events.get(0).getEntity().getId());
+
+ events = dmm.createOrUpdateCourse(courseMessage);
+ assertEquals(0, events.size());
+ }
+
}
\ No newline at end of file
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
