Thread: [Cse-ip-svn-commits] SF.net SVN: cse-ip:[167] trunk/cse-ip/sc-cdmm/src

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 422-6466

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.




Thread: [Cse-ip-svn-commits] SF.net SVN: cse-ip:[167] trunk/cse-ip/sc-cdmm/src

cse-ip-svn-commits