eadventureVars){
+ for (EadventureVars var: eadventureVars) {
+ if (var.getName().equals(name)) {
+ return var;
+
+ }
+ }
+ return null;
+
+ }
+
+
+
+ //TODO IMPORRRRRRRRRRRRRRRTANTE!!!!!!!!!!!!!!! el par�metro toolContentID que estamos pasando es realmente toolSessionID!!!!
+ @Override
+ public boolean setAppletInput(String name, String value, String userId, String toolContentID) {
+ //TODO restart when
+ EadventureServiceImpl.log.error("EEEEEEEEEEEEEEEEEE " + name);
+ EadventureServiceImpl.log.error("EEEEEEEEEEEEEEEEEE " + value);
+ //EadventureServiceImpl.log.error("USER ID "+ userId);
+ EadventureServiceImpl.log.error("TOOL SESION ID "+ toolContentID);
+ EadventureServiceImpl.log.error("OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOEEEEEEEEEEEEEEEE");
+
+
+ //TODO Ahora recuperamos la session para sacar el EAD!!! pero a�adir el toolContentId para que sea mas sencillo!!!
+ //TODO user va a sobrar!! con el userID que ya se nos pasa por par�metro vamos sobraos!!
+ //EadventureUser user = eadventureUserDao.getUserByUserIDAndContentID(Long.parseLong(userId), Long.parseLong(toolContentID));
+ EadventureUser user = eadventureUserDao.getUserByUserIDAndSessionID(Long.parseLong(userId), Long.parseLong(toolContentID));
+ //eadventureUserDao.getUserByUserIDAndSessionID(Long.parseLong(userId), Long.parseLong(toolSessionID));
+ EadventureServiceImpl.log.error("USER ID "+ user.getUserId());
+ EadventureSession eadSession = eadventureSessionDao.getSessionBySessionId( Long.parseLong(toolContentID));
+ //Eadventure ead = eadventureDao.getByContentId(Long.parseLong(toolContentID));
+ EadventureItemVisitLog log = eadventureItemVisitDao.getEadventureItemLog(eadSession.getEadventure().getUid(), user.getUserId());
+ EadventureVars var = eadventureVarsDao.getEadventureVars(log.getUid(), name);
+ if (var==null){
+ var = new EadventureVars();
+ var.setName(name);
+ var.setVisitLog(log);
+ //TODO ver el type
+ //var.setType(type);
+ }
+ var.setValue(value);
+ this.eadventureVarsDao.saveObject(var);
+ boolean changeButton = eadSession.getEadventure().isDefineComplete()&!log.isComplete();
+ if (name.equals("completed")&&value.equals("true")&&changeButton)
+ setItemComplete(eadSession.getEadventure().getUid(), Long.parseLong(userId), eadSession.getSessionId());
+
+ return changeButton;
+ }
+
+ @Override
+ public void setReportInput(String name, String value, String userId, String toolSessionID) {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ public EadventureItemVisitLog getEadventureItemLog(Long itemUid, Long userId) {
+
+ return eadventureItemVisitDao.getEadventureItemLog(itemUid, userId);
+ }
+
+ @Override
+ public EadventureVars getEadventureVars(Long itemVisitLogID, String name) {
+ return eadventureVarsDao.getEadventureVars(itemVisitLogID, name);
+ }
+
+ public void setEadventureParamDao(EadventureParamDAO eadventureParamDao) {
+ this.eadventureParamDao = eadventureParamDao;
+ }
+
+ public void setEadventureConditionDao(EadventureConditionDAO eadventureConditionDao) {
+ this.eadventureConditionDao = eadventureConditionDao;
+ }
+
+ public void setEadventureExpressionDao(EadventureExpressionDAO eadventureExpressionDao) {
+ this.eadventureExpressionDao = eadventureExpressionDao;
+ }
+
+
+
+
+
+
+}
Index: lams_tool_eadventure/src/java/org/eucm/lams/tool/eadventure/service/EadventureServiceProxy.java
===================================================================
diff -u
--- lams_tool_eadventure/src/java/org/eucm/lams/tool/eadventure/service/EadventureServiceProxy.java (revision 0)
+++ lams_tool_eadventure/src/java/org/eucm/lams/tool/eadventure/service/EadventureServiceProxy.java (revision e7b84a8dda80b775d674d686a2564d40c7e3f871)
@@ -0,0 +1,75 @@
+/****************************************************************
+ * Copyright (C) 2005 LAMS Foundation (http://lamsfoundation.org)
+ * =============================================================
+ * License Information: http://lamsfoundation.org/licensing/lams/2.0/
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
+ * USA
+ *
+ * http://www.gnu.org/licenses/gpl.txt
+ * ****************************************************************
+ */
+/* $$Id$$ */
+package org.eucm.lams.tool.eadventure.service;
+
+import javax.servlet.ServletContext;
+
+import org.lamsfoundation.lams.tool.ToolContentManager;
+import org.lamsfoundation.lams.tool.ToolSessionManager;
+import org.eucm.lams.tool.eadventure.EadventureConstants;
+import org.springframework.web.context.WebApplicationContext;
+import org.springframework.web.context.support.WebApplicationContextUtils;
+
+
+
+
+/**
+ * @author Dapeng.Ni
+ *
+ * This class act as the proxy between web layer and service layer. It is
+ * designed to decouple the presentation logic and business logic completely.
+ * In this way, the presentation tier will no longer be aware of the changes in
+ * service layer. Therefore we can feel free to switch the business logic
+ * implementation.
+ */
+public class EadventureServiceProxy
+{
+ /**
+ * Return the domain service object. It will delegate to the Spring
+ * helper method to retrieve the proper bean from Spring bean factory.
+ * @param servletContext the servletContext for current application
+ * @return Shared eadventure service object.
+ */
+ public static final IEadventureService getEadventureService(ServletContext servletContext)
+ {
+ return (IEadventureService)getEadventureDomainService(servletContext);
+ }
+
+ public static final ToolSessionManager getSessionManager(ServletContext servletContext)
+ {
+ return (ToolSessionManager)getEadventureDomainService(servletContext);
+ }
+
+ public static final ToolContentManager getContentManager(ServletContext servletContext)
+ {
+ return (ToolContentManager)getEadventureDomainService(servletContext);
+ }
+
+ private static Object getEadventureDomainService(ServletContext servletContext)
+ {
+ WebApplicationContext wac = WebApplicationContextUtils.getRequiredWebApplicationContext(servletContext);
+ return wac.getBean(EadventureConstants.RESOURCE_SERVICE);
+ }
+
+}
Index: lams_tool_eadventure/src/java/org/eucm/lams/tool/eadventure/service/IEadventureService.java
===================================================================
diff -u
--- lams_tool_eadventure/src/java/org/eucm/lams/tool/eadventure/service/IEadventureService.java (revision 0)
+++ lams_tool_eadventure/src/java/org/eucm/lams/tool/eadventure/service/IEadventureService.java (revision e7b84a8dda80b775d674d686a2564d40c7e3f871)
@@ -0,0 +1,353 @@
+/****************************************************************
+ * Copyright (C) 2005 LAMS Foundation (http://lamsfoundation.org)
+ * =============================================================
+ * License Information: http://lamsfoundation.org/licensing/lams/2.0/
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
+ * USA
+ *
+ * http://www.gnu.org/licenses/gpl.txt
+ * ****************************************************************
+ */
+/* $$Id$$ */
+package org.eucm.lams.tool.eadventure.service;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.SortedSet;
+
+import org.apache.struts.upload.FormFile;
+import org.lamsfoundation.lams.contentrepository.IVersionedNode;
+import org.lamsfoundation.lams.events.IEventNotificationService;
+import org.lamsfoundation.lams.notebook.model.NotebookEntry;
+import org.eucm.lams.tool.eadventure.dto.ReflectDTO;
+import org.eucm.lams.tool.eadventure.dto.Summary;
+import org.eucm.lams.tool.eadventure.model.Eadventure;
+import org.eucm.lams.tool.eadventure.model.EadventureAttachment;
+import org.eucm.lams.tool.eadventure.model.EadventureCondition;
+import org.eucm.lams.tool.eadventure.model.EadventureExpression;
+import org.eucm.lams.tool.eadventure.model.EadventureItemVisitLog;
+import org.eucm.lams.tool.eadventure.model.EadventureParam;
+import org.eucm.lams.tool.eadventure.model.EadventureSession;
+import org.eucm.lams.tool.eadventure.model.EadventureUser;
+import org.eucm.lams.tool.eadventure.model.EadventureVars;
+import org.lamsfoundation.lams.usermanagement.User;
+
+/**
+ * @author Dapeng.Ni
+ *
+ * Interface that defines the contract that all ShareEadventure service provider must follow.
+ */
+public interface IEadventureService {
+
+
+ public void removeParams(Long toolContentId);
+
+ public List getEadventureParamByContentId(Long contentId);
+
+ public EadventureVars getEadventureVars(Long itemVisitLogID,String name);
+
+ public EadventureItemVisitLog getEadventureItemLog(Long itemUid,Long userId);
+
+ /**
+ * Recibir report del applet
+ */
+ void setReportInput(String name,String value, String userId, String toolSessionID);
+
+
+ /**
+ * Get applet params and set it values in the associated eadventure vars.
+ * @return true if the eadventure is not completed and it was defined as defineCompleted
+ * in order to indicate VarsExchangeServlet to send or not javascript order.
+ */
+ boolean setAppletInput(String name,String value, String userId, String toolSessionID);
+
+ /**
+ * Get file IVersiondNode by given package id and path.
+ *
+ * @param packageId
+ * @param relPathString
+ * @return
+ * @throws EadventureApplicationException
+ */
+ IVersionedNode getFileNode(Long packageId, String relPathString) throws EadventureApplicationException;
+
+ /**
+ * Get Eadventure by toolContentID.
+ *
+ * @param contentId
+ * @return
+ */
+ Eadventure getEadventureByContentId(Long contentId);
+
+ /**
+ * Get a cloned copy of tool default tool content (Eadventure) and assign the toolContentId of that copy as the given
+ * contentId
+ *
+ * @param contentId
+ * @return
+ * @throws EadventureApplicationException
+ */
+ Eadventure getDefaultContent(Long contentId) throws EadventureApplicationException;
+
+ /**
+ * Get list of eadventure items by given eadventureUid. These eadventure items must be created by author.
+ *
+ * @param eadventureUid
+ * @return
+ */
+ // List getAuthoredItems(Long eadventureUid);
+
+ /**
+ * Upload instruciton file into repository.
+ *
+ * @param file
+ * @param type
+ * @return
+ * @throws UploadEadventureFileException
+ */
+ EadventureAttachment uploadInstructionFile(FormFile file, String type) throws UploadEadventureFileException;
+
+ /**
+ * Upload eadventure file to repository.
+ *
+ * @param eAdventure
+ * @param file
+ * @throws UploadEadventureFileException
+ */
+ void uploadEadventureFile(Eadventure item, FormFile file) throws UploadEadventureFileException;
+
+ // ********** for user methods *************
+ /**
+ * Create a new user in database.
+ */
+ void createUser(EadventureUser eadventureUser);
+
+ /**
+ * Get user by given userID and toolContentID.
+ *
+ * @param long1
+ * @return
+ */
+ EadventureUser getUserByIDAndContent(Long userID, Long contentId);
+
+ /**
+ * Get user by sessionID and UserID
+ *
+ * @param long1
+ * @param sessionId
+ * @return
+ */
+ EadventureUser getUserByIDAndSession(Long long1, Long sessionId);
+
+ // ********** Repository methods ***********************
+ /**
+ * Delete file from repository.
+ */
+ void deleteFromRepository(Long fileUuid, Long fileVersionId) throws EadventureApplicationException;
+
+ /**
+ * Save or update eadventure into database.
+ *
+ * @param Eadventure
+ */
+ void saveOrUpdateEadventure(Eadventure Eadventure);
+
+ /**
+ * Delete reource attachment(i.e., offline/online instruction file) from database. This method does not delete the
+ * file from repository.
+ *
+ * @param attachmentUid
+ */
+ void deleteEadventureAttachment(Long attachmentUid);
+
+
+ public void saveOrUpdateEadventureConditions(Set eadConditions);
+
+ public void saveOrUpdateEadventureExpressions(Set eadExpressions, Long condUID);
+
+ public void saveOrUpdateEadventureCondition(EadventureCondition eadCondition);
+
+ public void saveOrUpdateEadventureExpression(EadventureExpression eadExpression);
+
+
+ public void deleteEadventureCondition(Long conditionUid);
+
+ public void deleteEadventureExpression(Long expressionUid);
+
+ /**
+ * Delete resoruce item from database.
+ *
+ * @param uid
+ */
+ //void deleteEadventureItem(Long uid);
+
+ /**
+ * Return all reource items within the given toolSessionID.
+ *
+ * @param sessionId
+ * @return
+ */
+ //List getEadventureItemsBySessionId(Long sessionId);
+
+ /**
+ * Get eadventure which is relative with the special toolSession.
+ *
+ * @param sessionId
+ * @return
+ */
+ Eadventure getEadventureBySessionId(Long sessionId);
+
+ /**
+ * Get eadventure toolSession by toolSessionId
+ *
+ * @param sessionId
+ * @return
+ */
+ EadventureSession getEadventureSessionBySessionId(Long sessionId);
+
+
+ /**
+ * Save or update eadventure session.
+ *
+ * @param resSession
+ */
+ void saveOrUpdateEadventureSession(EadventureSession resSession);
+
+ //void retrieveComplete(SortedSet eadventureItemList, EadventureUser user);
+
+ void setItemComplete(Long eadventureItemUid, Long userId, Long sessionId);
+
+ void setItemAccess(Long eadventureItemUid, Long userId, Long sessionId);
+
+ /**
+ * the reqired number minus the count of view of the given user.
+ *
+ * @param userUid
+ * @return
+ */
+ // int checkMiniView(Long toolSessionId, Long userId);
+
+ /**
+ * If success return next activity's url, otherwise return null.
+ *
+ * @param toolSessionId
+ * @param userId
+ * @return
+ */
+ String finishToolSession(Long toolSessionId, Long userId) throws EadventureApplicationException;
+
+ //EadventureItem getEadventureItemByUid(Long itemUid);
+
+ void saveOrUpdateEadventureParams(Set eadParams);
+
+ /**
+ * Return monitoring summary list. The return value is list of eadventure summaries for each groups.
+ *
+ * @param contentId
+ * @return
+ */
+ List getSummary(Long contentId);
+
+ List getUserListBySessionItem(Long sessionId, Long itemUid);
+
+ /**
+ * Set a eadventure item visible or not.
+ *
+ * @param itemUid
+ * @param visible
+ * true, item is visible. False, item is invisible.
+ */
+ void setItemVisible(Long itemUid, boolean visible);
+
+ /**
+ * Get eadventure item Summary list according to sessionId
+ *
+ * @return
+ */
+ public List exportBySessionId(Long sessionId, Long userId);
+
+ public List exportByContentId(Long contentId);
+
+ /**
+ * Create refection entry into notebook tool.
+ *
+ * @param sessionId
+ * @param notebook_tool
+ * @param tool_signature
+ * @param userId
+ * @param entryText
+ */
+ public Long createNotebookEntry(Long sessionId, Integer notebookToolType, String toolSignature, Integer userId,
+ String entryText);
+
+ /**
+ * Get reflection entry from notebook tool.
+ *
+ * @param sessionId
+ * @param idType
+ * @param signature
+ * @param userID
+ * @return
+ */
+ public NotebookEntry getEntry(Long sessionId, Integer idType, String signature, Integer userID);
+
+ /**
+ * @param notebookEntry
+ */
+ public void updateEntry(NotebookEntry notebookEntry);
+
+ /**
+ * Get Reflect DTO list grouped by sessionID.
+ *
+ * @param contentId
+ * @return
+ */
+ Map> getReflectList(Long contentId, boolean setEntry);
+
+ /**
+ * Get user by UID
+ *
+ * @param uid
+ * @return
+ */
+ EadventureUser getUser(Long uid);
+
+ public IEventNotificationService getEventNotificationService();
+
+ /**
+ * Gets a message from eadventure bundle. Same as HttpSession via. Notice,
+ * this save is not persist them into database, just save
+ * HttpSession temporarily. Only they will be persist when the
+ * entire authoring page is being persisted.
+ *
+ * @param mapping
+ * @param form
+ * @param request
+ * @param response
+ * @return
+ * @throws ServletException
+ */
+ private ActionForward saveOrUpdateGame(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) {
+
+
+ EadventureGameForm gameForm = (EadventureGameForm) form;
+ // get back sessionMAP
+ SessionMap sessionMap = (SessionMap) request.getSession().getAttribute(gameForm.getSessionMapID());
+
+ Eadventure eadventure = ((EadventureForm)sessionMap.get(EadventureConstants.ATTR_RESOURCE_FORM)).getEadventure();
+
+ ActionErrors errors = new ActionErrors();
+ FormFile file = ((EadventureGameForm)form).getFile();
+ if (file.getFileName()==null||file.getFileName().equals(""))
+ errors.add(ActionMessages.GLOBAL_MESSAGE, new ActionMessage(
+ EadventureConstants.ERROR_NOT_EAD_ADD));
+
+ if (!errors.isEmpty()) {
+ this.addErrors(request, errors);
+ //request.setAttribute(EadventureConstants.ATTR_INSTRUCTION_LIST, instructionList);
+ request.setAttribute(EadventureConstants.ATTR_SESSION_MAP_ID, gameForm.getSessionMapID());
+ return mapping.findForward("addgame");
+ }
+
+ // if the conditions list is not empty, add conditions to deleteConditionsList to delete form the data base
+ // when the eadventure object will be persistent
+
+ //TODO comprobar, lo hacemos en update game tb.....
+ /*Set conditions = eadventure.getConditions();
+ if (conditions.size()!=0){
+ List delEadventureConditionList = getDeletedEadventureConditionList(sessionMap);
+ delEadventureConditionList.addAll(conditions);
+ sessionMap.put(EadventureConstants.ATTR_DELETED_CONDITION_LIST, delEadventureConditionList);
+ // add the related expressions to their delete list
+ List delEadventureExpressionList = this.getDeletedEadventureExpressionList(sessionMap);
+ for (EadventureCondition condition: conditions){
+ Set expressions = condition.getEadListExpression();
+ delEadventureExpressionList.addAll(expressions);
+ }
+ //reset conditions
+ eadventure.setConditions(new HashSet());
+ }*/
+ try {
+
+ IEadventureService service = getEadventureService();
+ service.uploadEadventureFile( eadventure, gameForm.getFile());
+
+ } catch (Exception e) {
+ // any upload exception will display as normal error message rather
+ // then throw exception directly
+ errors.add(ActionMessages.GLOBAL_MESSAGE, new ActionMessage(EadventureConstants.ERROR_MSG_UPLOAD_FAILED, e.getMessage()));
+ if (!errors.isEmpty()) {
+ this.addErrors(request, errors);
+ return mapping.findForward("addgame");
+ }
+ }
+ sessionMap.put(EadventureConstants.ATTR_HAS_FILE, "true");
+ List paramList = this.getEdventureParamList(sessionMap);
+ paramList.clear();
+ paramList.addAll(eadventure.getParams());
+ sessionMap.put(EadventureConstants.ATTR_PARAMS_LIST, paramList);
+ sessionMap.put(EadventureConstants.ATTR_CHANGE_FILE, "true");
+ ((EadventureForm)sessionMap.get(EadventureConstants.ATTR_RESOURCE_FORM)).setHasFile(true);
+ // set session map ID so that itemlist.jsp can get sessionMAP
+ request.setAttribute(EadventureConstants.ATTR_SESSION_MAP_ID, gameForm.getSessionMapID());
+ request.setAttribute(EadventureConstants.ATTR_GAME_DELETE, "false");
+ // return null to close this window
+ return mapping.findForward(EadventureConstants.SUCCESS);
+ }
+
+ /**
+ * Remove eadventure game. It is a ajax call and just temporarily remove from page, all
+ * permenant change will happen only when user sumbit this eadventure
+ * again.
+ *
+ * @param mapping
+ * @param form
+ * @param request
+ * @param response
+ * @return
+ */
+ private ActionForward removeGameAttachment(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) {
+ String sessionMapID = WebUtil.readStrParam(request, EadventureConstants.ATTR_SESSION_MAP_ID);
+ SessionMap sessionMap = (SessionMap) request.getSession().getAttribute(sessionMapID);
+ EadventureForm existForm = (EadventureForm) sessionMap.get(EadventureConstants.ATTR_RESOURCE_FORM);
+ // Add to delete list all the conditions and game params
+ List delCondList = getDeletedEadventureConditionList(sessionMap);
+ delCondList.addAll(existForm.getEadventure().getConditions());
+
+
+ //TODO comprobar que etsa bien: solo hay que meter en deleteExpresion cuando borramos la expression, no la cond (xk como
+ // estan definidas las tablas)
+ //Set conditions = existForm.getEadventure().getConditions();
+ //List condList = new ArrayList(conditions);
+ //List delExprlList = getDeletedEadventureExpressionList(sessionMap);
+ /*for (EadventureCondition eadc: condList ){
+ delCondList.add(eadc);
+ delExprlList.addAll(eadc.getEadListExpression());
+ }*/
+
+
+ // the same with the params
+ List delParamsList = getDeletedEadventureParamsList(sessionMap);
+ delParamsList.addAll(existForm.getEadventure().getParams());
+
+
+ sessionMap.put(EadventureConstants.ATTR_CONDITION_LIST, null);
+ sessionMap.put(EadventureConstants.ATTR_EXPRESSION_LIST, null);
+ sessionMap.put(EadventureConstants.ATTR_PARAMS_LIST, null);
+
+ existForm.resetFileInfo();
+ request.setAttribute(EadventureConstants.ATTR_SESSION_MAP_ID, sessionMapID);
+ sessionMap.put(EadventureConstants.ATTR_HAS_FILE, "false");
+ // TODO esta no funciona, se ha arreglado de otra manera en la view, comprobar
+ request.setAttribute(EadventureConstants.ATTR_GAME_DELETE, 1 );
+ return mapping.findForward(EadventureConstants.SUCCESS);
+ }
+
+ /**
+ * Remove eadventure item from HttpSession list and update page display. As
+ * authoring rule, all persist only happen when user submit whole page. So
+ * this remove is just impact HttpSession values.
+ *
+ * @param mapping
+ * @param form
+ * @param request
+ * @param response
+ * @return
+ */
+ private ActionForward removeItem(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) {
+
+ // get back sessionMAP
+ String sessionMapID = WebUtil.readStrParam(request, EadventureConstants.ATTR_SESSION_MAP_ID);
+ SessionMap sessionMap = (SessionMap) request.getSession().getAttribute(sessionMapID);
+
+ //int itemIdx = NumberUtils.stringToInt(request.getParameter(EadventureConstants.PARAM_ITEM_INDEX), -1);
+ /*if (itemIdx != -1) {
+ SortedSet eadventureList = getEadventureItemList(sessionMap);
+ List rList = new ArrayList(eadventureList);
+ EadventureItem item = rList.remove(itemIdx);
+ eadventureList.clear();
+ eadventureList.addAll(rList);
+ // add to delList
+ List delList = getDeletedEadventureItemList(sessionMap);
+ delList.add(item);
+ }*/
+
+ request.setAttribute(EadventureConstants.ATTR_SESSION_MAP_ID, sessionMapID);
+ return mapping.findForward(EadventureConstants.SUCCESS);
+ }
+
+
+
+
+
+ /**
+ * Ajax call, will add one more input line for new eadventure item
+ * instruction.
+ *
+ * @param mapping
+ * @param form
+ * @param request
+ * @param response
+ * @return
+ */
+ private ActionForward newInstruction(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) {
+ int numberOfInstructions = getNumberOfInstructionsInRequest(request);
+ List instructionList = new ArrayList(++numberOfInstructions);
+ for (int idx = 0; idx < numberOfInstructions; idx++) {
+ String item = request.getParameter(AuthoringAction.INSTRUCTION_ITEM_DESC_PREFIX + idx);
+ if (item == null) {
+ instructionList.add("");
+ } else {
+ instructionList.add(item);
+ }
+ }
+ request.setAttribute(EadventureConstants.ATTR_INSTRUCTION_LIST, instructionList);
+ return mapping.findForward(EadventureConstants.SUCCESS);
+ }
+
+ /**
+ * Ajax call, remove the given line of instruction of eadventure item.
+ *
+ * @param mapping
+ * @param form
+ * @param request
+ * @param response
+ * @return
+ */
+ private ActionForward removeInstruction(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) {
+ int numberOfInstructions = getNumberOfInstructionsInRequest(request);
+ int removeIdx = NumberUtils.stringToInt(request.getParameter("removeIdx"), -1);
+ List instructionList = new ArrayList(numberOfInstructions - 1);
+ for (int idx = 0; idx < numberOfInstructions; idx++) {
+ String item = request.getParameter(AuthoringAction.INSTRUCTION_ITEM_DESC_PREFIX + idx);
+ if (idx == removeIdx) {
+ continue;
+ }
+ if (item == null) {
+ instructionList.add("");
+ } else {
+ instructionList.add(item);
+ }
+ }
+ request.setAttribute(EadventureConstants.ATTR_INSTRUCTION_LIST, instructionList);
+ return mapping.findForward(EadventureConstants.SUCCESS);
+ }
+
+
+
+
+
+ /**
+ * This method will persist all inforamtion in this authoring page.
+ *
+ * @param mapping
+ * @param form
+ * @param request
+ * @param response
+ * @return
+ * @throws ServletException
+ */
+ private ActionForward updateContent(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
+ EadventureForm eadventureForm = (EadventureForm) form;
+
+ // get back sessionMAP
+ SessionMap sessionMap = (SessionMap) request.getSession().getAttribute(eadventureForm.getSessionMapID());
+
+ ToolAccessMode mode = getAccessMode(request);
+
+ //TODO mirar si merece la pena llevar el form por sessionMap?�?�?
+ //Eadventure eadventure = eadventureForm.getEadventure();
+ Eadventure eadventure = ((EadventureForm)sessionMap.get(EadventureConstants.ATTR_RESOURCE_FORM)).getEadventure();
+
+
+ ActionMessages errors = validate(eadventureForm, mapping, request);
+ String file = eadventure.getFileName();
+ if (file==null||file.equals(""))
+ errors.add(ActionMessages.GLOBAL_MESSAGE, new ActionMessage(
+ EadventureConstants.ERROR_NOT_EAD_ADD));
+ if (!errors.isEmpty()) {
+ saveErrors(request, errors);
+ if (mode.isAuthor()) {
+ return mapping.findForward("author");
+ } else {
+ return mapping.findForward("monitor");
+ }
+ }
+
+
+ IEadventureService service = getEadventureService();
+
+ // **********************************Get Eadventure
+ // PO*********************
+ Eadventure eadventurePO = service.getEadventureByContentId(eadventureForm.getEadventure().getContentId());
+ if (eadventurePO == null) {
+ // new Eadventure, create it.
+ eadventurePO = eadventure;
+ eadventurePO.setCreated(new Timestamp(new Date().getTime()));
+ eadventurePO.setUpdated(new Timestamp(new Date().getTime()));
+ } else {
+ //TODO revisar el deine later!!
+ if (mode.isAuthor()) {
+ Long uid = eadventurePO.getUid();
+ //Set params = eadventurePO.getParams();
+ //Set conditions = eadventurePO.getConditions();
+ Date created = eadventurePO.getCreated();
+ PropertyUtils.copyProperties(eadventurePO, eadventure);
+ // get back UID
+ eadventurePO.setUid(uid);
+ eadventurePO.setCreated(created);
+ } else { // if it is Teacher, then just update basic tab content
+ // (definelater)
+ eadventurePO.setInstructions(eadventure.getInstructions());
+ eadventurePO.setTitle(eadventure.getTitle());
+ // change define later status
+ eadventurePO.setDefineLater(false);
+ }
+ eadventurePO.setUpdated(new Timestamp(new Date().getTime()));
+ }
+ // *******************************Handle user*******************
+ // try to get form system session
+ HttpSession ss = SessionManager.getSession();
+ // get back login user DTO
+ UserDTO user = (UserDTO) ss.getAttribute(AttributeNames.USER);
+ EadventureUser eadventureUser = service.getUserByIDAndContent(new Long(user.getUserID().intValue()), eadventureForm.getEadventure().getContentId());
+ if (eadventureUser == null) {
+ eadventureUser = new EadventureUser(user, eadventurePO);
+ }
+ eadventurePO.setCreatedBy(eadventureUser);
+ // **********************************Handle Authoring Instruction
+ // Attachement *********************
+ // merge attachment info
+ // so far, attPOSet will be empty if content is existed. because
+ // PropertyUtils.copyProperties() is executed
+ // For eAdventure tool only store as attachements the online-offline instructions files
+ Set attPOSet = eadventurePO.getAttachments();
+ if (attPOSet == null) {
+ attPOSet = new HashSet();
+ }
+ List attachmentList = getAttachmentList(sessionMap);
+ List deleteAttachmentList = getDeletedAttachmentList(sessionMap);
+
+ // current attachemnt in authoring instruction tab.
+ Iterator iter = attachmentList.iterator();
+ while (iter.hasNext()) {
+ EadventureAttachment newAtt = (EadventureAttachment) iter.next();
+ attPOSet.add(newAtt);
+ }
+ attachmentList.clear();
+
+ // deleted attachment. 2 possible types: one is persist another is
+ // non-persist before.
+ iter = deleteAttachmentList.iterator();
+ while (iter.hasNext()) {
+ EadventureAttachment delAtt = (EadventureAttachment) iter.next();
+ iter.remove();
+ // it is an existed att, then delete it from current attachmentPO
+ if (delAtt.getUid() != null) {
+ Iterator attIter = attPOSet.iterator();
+ while (attIter.hasNext()) {
+ EadventureAttachment att = (EadventureAttachment) attIter.next();
+ if (delAtt.getUid().equals(att.getUid())) {
+ attIter.remove();
+ break;
+ }
+ }
+ service.deleteEadventureAttachment(delAtt.getUid());
+ }// end remove from persist value
+ }
+
+ // copy back
+ eadventurePO.setAttachments(attPOSet);
+
+ service.saveOrUpdateEadventureParams(eadventurePO.getParams());
+
+ // Handle taskList conditions. Also delete conditions that don't contain any taskLIstItems.
+ SortedSet conditionList = getEadventureConditionList(sessionMap);
+ List delEadventureConditionList = getDeletedEadventureConditionList(sessionMap);
+ //iter = conditionList.iterator();
+ if (conditionList.size()>0)
+ service.saveOrUpdateEadventureConditions(conditionList);
+ /*while (iter.hasNext()) {
+ EadventureCondition condition = (EadventureCondition) iter.next();
+ Set eadExprList = condition.getEadListExpression();
+ if (condition.getUid()==null){
+ condition.setEadListExpression(null);
+ service.saveOrUpdateEadventureCondition(condition);
+ Iterator it2 = eadExprList.iterator();
+ while (it2.hasNext()){
+ EadventureExpression eadExp = (EadventureExpression)it2.next();
+ // eadExp.setCondition_uid(condition.getUid());
+ service.saveOrUpdateEadventureExpression(eadExp);
+ }
+ }else {
+ Iterator it2 = eadExprList.iterator();
+ while (it2.hasNext()){
+ EadventureExpression eadExp = (EadventureExpression)it2.next();
+ //eadExp.setCondition_uid(condition.getUid());
+ service.saveOrUpdateEadventureExpression(eadExp);
+ }
+ service.saveOrUpdateEadventureCondition(condition);
+ }
+
+ }*/
+ eadventurePO.setConditions(conditionList);
+ // this method also saves the eAdventure expressions associated to each condition in the list
+ //TODO ver si merece la pena revisar si ha habido algun cambio en cada una de las condiciones, y en caso afirmativo guardar
+
+
+
+
+ // delete TaEadventureConditionfrom database.
+ iter = delEadventureConditionList.iterator();
+ while (iter.hasNext()) {
+ EadventureCondition condition = (EadventureCondition) iter.next();
+ iter.remove();
+
+ if (condition.getUid() != null) {
+ service.deleteEadventureCondition(condition.getUid());
+ }
+ }
+
+ //SortedSet expressionList = getEadventureConditionList(sessionMap);
+ //SortedSet expressionListWithoutEmptyElements = new TreeSet(conditionList);
+ List delEadventureExpressionList = getDeletedEadventureExpressionList(sessionMap);
+
+
+ // delete TaEadventureConditionfrom database.
+ iter = delEadventureExpressionList.iterator();
+ while (iter.hasNext()) {
+ EadventureExpression expression = (EadventureExpression) iter.next();
+ if (expression.getUid() != null) {
+ service.deleteEadventureExpression(expression.getUid());
+ }
+ iter.remove();
+ }
+
+
+
+ // finally persist eadventurePO again
+ //eadventurePO.setParams(eadventurePO.getParams());
+ //if (eadventureForm.getFile()==null)
+ String changeFile = (String) sessionMap.get(EadventureConstants.ATTR_CHANGE_FILE);
+ String openSavedGame = (String) sessionMap.get(EadventureConstants.ATTR_OPEN_SAVED_GAME);
+ if (changeFile.equals("true")&&openSavedGame.equals("true")){
+ //remove the old params
+
+ //service.removeParams(getDeletedEadventureConditionList(sessionMap));
+ List delParamsList = getDeletedEadventureParamsList(sessionMap);
+ Iterator it = delParamsList.iterator();
+ while (it.hasNext()) {
+ EadventureParam eadp = (EadventureParam)it.next();
+ service.removeParam(eadp);
+ }
+ //service.saveOrUpdateEadventureParams(eadventurePO.getParams());
+ //service.uploadEadventureFile(eadventurePO, eadventureForm.getFile());
+ //TODO borrar condiciones y expressiones
+
+ }
+ //TODO ver si hay que borrar params
+ //if (openSavedGame.equals("false"))
+ // service.saveOrUpdateEadventureParams(eadventurePO.getParams());
+
+
+ service.saveOrUpdateEadventure(eadventurePO);
+
+ //TODO por que???
+ // initialize attachmentList again
+ attachmentList = getAttachmentList(sessionMap);
+ attachmentList.addAll(eadventure.getAttachments());
+ eadventureForm.setEadventure(eadventurePO);
+
+ request.setAttribute(AuthoringConstants.LAMS_AUTHORING_SUCCESS_FLAG, Boolean.TRUE);
+ if (mode.isAuthor()) {
+ return mapping.findForward("author");
+ } else {
+ return mapping.findForward("monitor");
+ }
+ }
+
+ /**
+ * Handle upload online instruction files request.
+ *
+ * @param mapping
+ * @param form
+ * @param request
+ * @param response
+ * @return
+ * @throws UploadEadventureFileException
+ */
+ public ActionForward uploadOnline(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response)
+ throws UploadEadventureFileException {
+ return uploadFile(mapping, form, IToolContentHandler.TYPE_ONLINE, request);
+ }
+
+ /**
+ * Handle upload offline instruction files request.
+ *
+ * @param mapping
+ * @param form
+ * @param request
+ * @param response
+ * @return
+ * @throws UploadEadventureFileException
+ */
+ public ActionForward uploadOffline(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response)
+ throws UploadEadventureFileException {
+ return uploadFile(mapping, form, IToolContentHandler.TYPE_OFFLINE, request);
+ }
+
+ /**
+ * Common method to upload online or offline instruction files request.
+ *
+ * @param mapping
+ * @param form
+ * @param type
+ * @param request
+ * @return
+ * @throws UploadEadventureFileException
+ */
+ private ActionForward uploadFile(ActionMapping mapping, ActionForm form, String type, HttpServletRequest request) throws UploadEadventureFileException {
+
+ EadventureForm eadventureForm = (EadventureForm) form;
+ // get back sessionMAP
+ SessionMap sessionMap = (SessionMap) request.getSession().getAttribute(eadventureForm.getSessionMapID());
+
+ FormFile file;
+ if (StringUtils.equals(IToolContentHandler.TYPE_OFFLINE, type)) {
+ file = eadventureForm.getOfflineFile();
+ } else {
+ file = eadventureForm.getOnlineFile();
+ }
+
+ if (file == null || StringUtils.isBlank(file.getFileName())) {
+ return mapping.findForward(EadventureConstants.SUCCESS);
+ }
+
+ // validate file size
+ ActionMessages errors = new ActionMessages();
+ FileValidatorUtil.validateFileSize(file, true, errors);
+ if (!errors.isEmpty()) {
+ this.saveErrors(request, errors);
+ return mapping.findForward(EadventureConstants.SUCCESS);
+ }
+
+ IEadventureService service = getEadventureService();
+ // upload to repository
+ EadventureAttachment att = service.uploadInstructionFile(file, type);
+ // handle session value
+ List attachmentList = getAttachmentList(sessionMap);
+ List deleteAttachmentList = getDeletedAttachmentList(sessionMap);
+ // first check exist attachment and delete old one (if exist) to
+ // deletedAttachmentList
+ Iterator iter = attachmentList.iterator();
+ EadventureAttachment existAtt;
+ while (iter.hasNext()) {
+ existAtt = (EadventureAttachment) iter.next();
+ if (StringUtils.equals(existAtt.getFileName(), att.getFileName()) && StringUtils.equals(existAtt.getFileType(), att.getFileType())) {
+ // if there is same name attachment, delete old one
+ deleteAttachmentList.add(existAtt);
+ iter.remove();
+ break;
+ }
+ }
+ // add to attachmentList
+ attachmentList.add(att);
+
+ return mapping.findForward(EadventureConstants.SUCCESS);
+
+ }
+
+ /**
+ * Delete offline instruction file from current Eadventure authoring page.
+ *
+ * @param mapping
+ * @param form
+ * @param request
+ * @param response
+ * @return
+ */
+ public ActionForward deleteOfflineFile(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) {
+ return deleteFile(mapping, request, response, form, IToolContentHandler.TYPE_OFFLINE);
+ }
+
+ /**
+ * Delete online instruction file from current Eadventure authoring page.
+ *
+ * @param mapping
+ * @param form
+ * @param request
+ * @param response
+ * @return
+ */
+ public ActionForward deleteOnlineFile(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) {
+ return deleteFile(mapping, request, response, form, IToolContentHandler.TYPE_ONLINE);
+ }
+
+ /**
+ * General method to delete file (online or offline)
+ *
+ * @param mapping
+ * @param request
+ * @param response
+ * @param form
+ * @param type
+ * @return
+ */
+ private ActionForward deleteFile(ActionMapping mapping, HttpServletRequest request, HttpServletResponse response, ActionForm form, String type) {
+ Long versionID = new Long(WebUtil.readLongParam(request, EadventureConstants.PARAM_FILE_VERSION_ID));
+ Long uuID = new Long(WebUtil.readLongParam(request, EadventureConstants.PARAM_FILE_UUID));
+
+ // get back sessionMAP
+ String sessionMapID = WebUtil.readStrParam(request, EadventureConstants.ATTR_SESSION_MAP_ID);
+ SessionMap sessionMap = (SessionMap) request.getSession().getAttribute(sessionMapID);
+
+ // handle session value
+ List attachmentList = getAttachmentList(sessionMap);
+ List deleteAttachmentList = getDeletedAttachmentList(sessionMap);
+ // first check exist attachment and delete old one (if exist) to
+ // deletedAttachmentList
+ Iterator iter = attachmentList.iterator();
+ EadventureAttachment existAtt;
+ while (iter.hasNext()) {
+ existAtt = (EadventureAttachment) iter.next();
+ if (existAtt.getFileUuid().equals(uuID) && existAtt.getFileVersionId().equals(versionID)) {
+ // if there is same name attachment, delete old one
+ deleteAttachmentList.add(existAtt);
+ iter.remove();
+ }
+ }
+
+ request.setAttribute(EadventureConstants.ATTR_FILE_TYPE_FLAG, type);
+ request.setAttribute(EadventureConstants.ATTR_SESSION_MAP_ID, sessionMapID);
+ return mapping.findForward(EadventureConstants.SUCCESS);
+
+ }
+
+ // *************************************************************************************
+ // Private method
+ // *************************************************************************************
+ /**
+ * Return EadventureService bean.
+ */
+ private IEadventureService getEadventureService() {
+ WebApplicationContext wac = WebApplicationContextUtils.getRequiredWebApplicationContext(getServlet().getServletContext());
+ return (IEadventureService) wac.getBean(EadventureConstants.RESOURCE_SERVICE);
+ }
+
+ /**
+ * @param request
+ * @return
+ */
+ private List getAttachmentList(SessionMap sessionMap) {
+ return getListFromSession(sessionMap, EadventureConstants.ATT_ATTACHMENT_LIST);
+ }
+
+
+
+ /**
+ * @param request
+ * @return
+ */
+ private List getDeletedAttachmentList(SessionMap sessionMap) {
+ return getListFromSession(sessionMap, EadventureConstants.ATTR_DELETED_ATTACHMENT_LIST);
+ }
+
+
+
+ /**
+ * List save deleted eadventure items, which could be persisted or
+ * non-persisted items.
+ *
+ * @param request
+ * @return
+ */
+ private List getDeletedEadventureItemList(SessionMap sessionMap) {
+ return getListFromSession(sessionMap, EadventureConstants.ATTR_DELETED_RESOURCE_ITEM_LIST);
+ }
+
+ /**
+ * If a eadventure item has attahment file, and the user edit this item and
+ * change the attachment to new file, then the old file need be deleted when
+ * submitting the whole authoring page. Save the file uuid and version id
+ * into EadventureItem object for temporarily use.
+ *
+ * @param request
+ * @return
+ */
+ private List getDeletedItemAttachmentList(SessionMap sessionMap) {
+ return getListFromSession(sessionMap, EadventureConstants.ATTR_DELETED_RESOURCE_ITEM_ATTACHMENT_LIST);
+ }
+
+
+ /**
+ * List save deleted eadventure conditions, which could be persisted or non-persisted conditions.
+ *
+ * @param request
+ * @return
+ */
+ private List getDeletedEadventureConditionList(SessionMap sessionMap) {
+ return getListFromSession(sessionMap, EadventureConstants.ATTR_DELETED_CONDITION_LIST);
+ }
+
+ /**
+ * List of deleted eadventure expressions, which could be persisted or non-persisted expressions.
+ *
+ * @param request
+ * @return
+ */
+ private List getDeletedEadventureExpressionList(SessionMap sessionMap) {
+ return getListFromSession(sessionMap, EadventureConstants.ATTR_DELETED_EXPRESSION_LIST);
+ }
+
+ /**
+ * List save deleted eadventure params, which could be persisted or non-persisted expressions.
+ *
+ * @param request
+ * @return
+ */
+ private List getDeletedEadventureParamsList(SessionMap sessionMap) {
+ return getListFromSession(sessionMap, EadventureConstants.ATTR_DELETED_PARAMS_LIST);
+ }
+ /**
+ * Get java.util.List from HttpSession by given name.
+ *
+ * @param request
+ * @param name
+ * @return
+ */
+ private List getListFromSession(SessionMap sessionMap, String name) {
+ List list = (List) sessionMap.get(name);
+ if (list == null) {
+ list = new ArrayList();
+ sessionMap.put(name, list);
+ }
+ return list;
+ }
+
+ /**
+ * Get eadventure items instruction from HttpRequest
+ *
+ * @param request
+ */
+ private List getInstructionsFromRequest(HttpServletRequest request) {
+ String list = request.getParameter("instructionList");
+ String[] params = list.split("&");
+ Map paramMap = new HashMap();
+ String[] pair;
+ for (String item : params) {
+ pair = item.split("=");
+ if (pair == null || pair.length != 2) {
+ continue;
+ }
+ try {
+ paramMap.put(pair[0], URLDecoder.decode(pair[1], "UTF-8"));
+ } catch (UnsupportedEncodingException e) {
+ AuthoringAction.log.error("Error occurs when decode instruction string:" + e.toString());
+ }
+ }
+
+ int count = paramMap.keySet().size();
+ List instructionList = new ArrayList();
+
+ for (int idx = 0; idx < count; idx++) {
+ String item = paramMap.get(AuthoringAction.INSTRUCTION_ITEM_DESC_PREFIX + idx);
+ if (item == null)
+ continue;
+
+ instructionList.add(item);
+ }
+
+ return instructionList;
+
+ }
+
+ /**
+ * Get number of instruction items in the HttpRequest
+ *
+ * @param request
+ * the HttpServletRequest
+ * @return numberOfInstruction the number of instructions in the request
+ */
+ private int getNumberOfInstructionsInRequest(HttpServletRequest request) {
+ int numberOfInstructions = 0;
+ Enumeration e = request.getParameterNames();
+ while (e.hasMoreElements()) {
+ if (e.nextElement().toString().indexOf(AuthoringAction.INSTRUCTION_ITEM_DESC_PREFIX) != -1)
+ numberOfInstructions++;
+ }
+ return numberOfInstructions;
+ }
+
+ /**
+ * List save current eadventure conditions.
+ *
+ * @param request
+ * @return
+ */
+ private SortedSet getEadventureConditionList(SessionMap sessionMap) {
+ SortedSet list = (SortedSet) sessionMap
+ .get(EadventureConstants.ATTR_CONDITION_LIST);
+ if (list == null) {
+ list = new TreeSet(new EadventureConditionComparator());
+ sessionMap.put(EadventureConstants.ATTR_CONDITION_LIST, list);
+ }
+ return list;
+ }
+
+ /**
+ * List save current eadventure params.
+ *
+ * @param request
+ * @return
+ */
+
+ private List getEdventureParamList(SessionMap sessionMap) {
+ return getListFromSession(sessionMap, EadventureConstants.ATTR_PARAMS_LIST);
+ }
+
+
+ /**
+ * Vaidate eadventure item regards to their type (url/file/learning
+ * object/website zip file)
+ *
+ * @param itemForm
+ * @return
+ */
+ /* private ActionErrors validateEadventureItem(EadventureItemForm itemForm) {
+ ActionErrors errors = new ActionErrors();
+ if (StringUtils.isBlank(itemForm.getTitle())) {
+ errors.add(ActionMessages.GLOBAL_MESSAGE, new ActionMessage(EadventureConstants.ERROR_MSG_TITLE_BLANK));
+ }
+
+ if (itemForm.getItemType() == EadventureConstants.RESOURCE_TYPE_URL) {
+ if (StringUtils.isBlank(itemForm.getUrl())) {
+ errors.add(ActionMessages.GLOBAL_MESSAGE, new ActionMessage(EadventureConstants.ERROR_MSG_URL_BLANK));
+ // URL validation: Commom URL validate(1.3.0) work not very
+ // well: it can not support http://
+ // address:port format!!!
+ // UrlValidator validator = new UrlValidator();
+ // if(!validator.isValid(itemForm.getUrl()))
+ // errors.add(ActionMessages.GLOBAL_MESSAGE,new
+ // ActionMessage(EadventureConstants.ERROR_MSG_INVALID_URL));
+ }
+ }
+ // if(itemForm.getItemType() == EadventureConstants.RESOURCE_TYPE_WEBSITE
+ // ||itemForm.getItemType() ==
+ // EadventureConstants.RESOURCE_TYPE_LEARNING_OBJECT){
+ // if(StringUtils.isBlank(itemForm.getDescription()))
+ // errors.add(ActionMessages.GLOBAL_MESSAGE,new
+ // ActionMessage(EadventureConstants.ERROR_MSG_DESC_BLANK));
+ // }
+ if (itemForm.getItemType() == EadventureConstants.RESOURCE_TYPE_WEBSITE || itemForm.getItemType() == EadventureConstants.RESOURCE_TYPE_LEARNING_OBJECT
+ || itemForm.getItemType() == EadventureConstants.RESOURCE_TYPE_FILE) {
+ // validate item size
+ FileValidatorUtil.validateFileSize(itemForm.getFile(), true, errors);
+ // for edit validate: file already exist
+ if (!itemForm.isHasFile() && (itemForm.getFile() == null || StringUtils.isEmpty(itemForm.getFile().getFileName()))) {
+ errors.add(ActionMessages.GLOBAL_MESSAGE, new ActionMessage(EadventureConstants.ERROR_MSG_FILE_BLANK));
+ }
+ }
+ return errors;
+ }
+/*
+ /**
+ * Get ToolAccessMode from HttpRequest parameters. Default value is AUTHOR
+ * mode.
+ *
+ * @param request
+ * @return
+ */
+ private ToolAccessMode getAccessMode(HttpServletRequest request) {
+ ToolAccessMode mode;
+ String modeStr = request.getParameter(AttributeNames.ATTR_MODE);
+ if (StringUtils.equalsIgnoreCase(modeStr, ToolAccessMode.TEACHER.toString())) {
+ mode = ToolAccessMode.TEACHER;
+ } else {
+ mode = ToolAccessMode.AUTHOR;
+ }
+ return mode;
+ }
+
+ private ActionMessages validate(EadventureForm eadventureForm, ActionMapping mapping, HttpServletRequest request) {
+ ActionMessages errors = new ActionMessages();
+ if (StringUtils.isBlank(eadventureForm.getEadventure().getTitle())) {
+ ActionMessage error = new
+ ActionMessage("error.resource.item.title.blank");
+ errors.add(ActionMessages.GLOBAL_MESSAGE, error);
+ }
+
+
+ // define it later mode(TEACHER) skip below validation.
+ String modeStr = request.getParameter(AttributeNames.ATTR_MODE);
+ if (StringUtils.equals(modeStr, ToolAccessMode.TEACHER.toString())) {
+ return errors;
+ }
+
+ // Some other validation outside basic Tab.
+
+ return errors;
+ }
+
+ public ActionForward initPedagogicalPlannerForm(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) {
+ EadventurePedagogicalPlannerForm plannerForm = (EadventurePedagogicalPlannerForm) form;
+ Long toolContentID = WebUtil.readLongParam(request, AttributeNames.PARAM_TOOL_CONTENT_ID);
+ Eadventure taskList = getEadventureService().getEadventureByContentId(toolContentID);
+ String command = WebUtil.readStrParam(request, AttributeNames.PARAM_COMMAND, true);
+ if (command == null) {
+ plannerForm.fillForm(taskList);
+ String contentFolderId = WebUtil.readStrParam(request, AttributeNames.PARAM_CONTENT_FOLDER_ID);
+ plannerForm.setContentFolderID(contentFolderId);
+ return mapping.findForward(EadventureConstants.SUCCESS);
+ } else {
+ try {
+ String onlineInstructions = taskList.getOnlineInstructions();
+ response.setContentType("text/html;charset=utf-8");
+ PrintWriter writer = response.getWriter();
+
+ if (AttributeNames.COMMAND_CHECK_EDITING_ADVICE.equals(command)) {
+ Integer activityIndex = WebUtil.readIntParam(request, AttributeNames.PARAM_ACTIVITY_INDEX);
+ String responseText = (StringUtils.isEmpty(taskList.getOnlineInstructions()) ? "NO" : "OK") + '&' + activityIndex;
+ writer.print(responseText);
+
+ } else if (AttributeNames.COMMAND_GET_EDITING_ADVICE.equals(command)) {
+ writer.print(onlineInstructions);
+ }
+ } catch (IOException e) {
+ AuthoringAction.log.error(e);
+ }
+ return null;
+ }
+
+ }
+
+ //TODO completar
+ public ActionForward saveOrUpdatePedagogicalPlannerForm(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response)
+ throws IOException {
+ EadventurePedagogicalPlannerForm plannerForm = (EadventurePedagogicalPlannerForm) form;
+ ActionMessages errors = plannerForm.validate();
+/* if (errors.isEmpty()) {
+ Eadventure taskList = getEadventureService().getEadventureByContentId(plannerForm.getToolContentID());
+ taskList.setInstructions(plannerForm.getInstructions());
+
+ int itemIndex = 0;
+ String title = null;
+ EadventureItem eadventureItem = null;
+ List newItems = new LinkedList();
+ Set eadventureItems = taskList.getEadventureItems();
+ Iterator taskListItemIterator = eadventureItems.iterator();
+ // We need to reverse the order, since the items are delivered
+ // newest-first
+ LinkedList reversedEadventureItems = new LinkedList();
+ while (taskListItemIterator.hasNext()) {
+ reversedEadventureItems.addFirst(taskListItemIterator.next());
+ }
+ taskListItemIterator = reversedEadventureItems.iterator();
+ do {
+ title = plannerForm.getTitle(itemIndex);
+ if (StringUtils.isEmpty(title)) {
+ plannerForm.removeItem(itemIndex);
+ } else {
+ if (taskListItemIterator.hasNext()) {
+ eadventureItem = taskListItemIterator.next();
+ } else {
+ eadventureItem = new EadventureItem();
+ eadventureItem.setCreateByAuthor(true);
+ Date currentDate = new Date();
+ eadventureItem.setCreateDate(currentDate);
+
+ HttpSession session = SessionManager.getSession();
+ UserDTO user = (UserDTO) session.getAttribute(AttributeNames.USER);
+ EadventureUser taskListUser = getEadventureService().getUserByIDAndContent(new Long(user.getUserID().intValue()),
+ plannerForm.getToolContentID());
+ eadventureItem.setCreateBy(taskListUser);
+
+ newItems.add(eadventureItem);
+ }
+ eadventureItem.setTitle(title);
+ Short type = plannerForm.getType(itemIndex);
+ eadventureItem.setType(type);
+ boolean hasFile = eadventureItem.getFileUuid() != null;
+ if (type.equals(EadventureConstants.RESOURCE_TYPE_URL)) {
+ eadventureItem.setUrl(plannerForm.getUrl(itemIndex));
+ if (hasFile) {
+ eadventureItem.setFileName(null);
+ eadventureItem.setFileUuid(null);
+ eadventureItem.setFileVersionId(null);
+ eadventureItem.setFileType(null);
+ }
+ } else if (type.equals(EadventureConstants.RESOURCE_TYPE_FILE)) {
+ FormFile file = plannerForm.getFile(itemIndex);
+ eadventureItem.setUrl(null);
+ IEadventureService service = getEadventureService();
+ if (file != null) {
+ try {
+ if (hasFile) {
+ // delete the old file
+ service.deleteFromRepository(eadventureItem.getFileUuid(), eadventureItem.getFileVersionId());
+ }
+ service.uploadEadventureItemFile(eadventureItem, file);
+ } catch (Exception e) {
+ AuthoringAction.log.error(e);
+ ActionMessage error = new ActionMessage("error.msg.io.exception");
+ errors.add(ActionMessages.GLOBAL_MESSAGE, error);
+ saveErrors(request, errors);
+ plannerForm.setValid(false);
+ return mapping.findForward(EadventureConstants.SUCCESS);
+ }
+ }
+ plannerForm.setFileName(itemIndex, eadventureItem.getFileName());
+ plannerForm.setFileUuid(itemIndex, eadventureItem.getFileUuid());
+ plannerForm.setFileVersion(itemIndex, eadventureItem.getFileVersionId());
+ plannerForm.setFile(itemIndex, null);
+ }
+ itemIndex++;
+ }
+
+ } while (title != null);
+ // we need to clear it now, otherwise we get Hibernate error (item
+ // re-saved by cascade)
+ taskList.getEadventureItems().clear();
+ while (taskListItemIterator.hasNext()) {
+ eadventureItem = taskListItemIterator.next();
+ taskListItemIterator.remove();
+ getEadventureService().deleteEadventureItem(eadventureItem.getUid());
+ }
+ reversedEadventureItems.addAll(newItems);
+
+ taskList.getEadventureItems().addAll(reversedEadventureItems);
+ getEadventureService().saveOrUpdateEadventure(taskList);
+ } else {
+ saveErrors(request, errors);
+ }*/
+ return mapping.findForward(EadventureConstants.SUCCESS);
+ }
+
+ public ActionForward createPedagogicalPlannerItem(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response)
+ throws IOException, ServletException {
+ EadventurePedagogicalPlannerForm plannerForm = (EadventurePedagogicalPlannerForm) form;
+ int insertIndex = plannerForm.getItemCount();
+ plannerForm.setTitle(insertIndex, "");
+ plannerForm.setType(insertIndex, new Short(request.getParameter(EadventureConstants.ATTR_ADD_RESOURCE_TYPE)));
+ plannerForm.setUrl(insertIndex, null);
+ plannerForm.setFileName(insertIndex, null);
+ plannerForm.setFile(insertIndex, null);
+ plannerForm.setFileUuid(insertIndex, null);
+ plannerForm.setFileVersion(insertIndex, null);
+ return mapping.findForward(EadventureConstants.SUCCESS);
+ }
+
+}
Index: lams_tool_eadventure/src/java/org/eucm/lams/tool/eadventure/web/action/AuthoringEadventureConditionAction.java
===================================================================
diff -u
--- lams_tool_eadventure/src/java/org/eucm/lams/tool/eadventure/web/action/AuthoringEadventureConditionAction.java (revision 0)
+++ lams_tool_eadventure/src/java/org/eucm/lams/tool/eadventure/web/action/AuthoringEadventureConditionAction.java (revision e7b84a8dda80b775d674d686a2564d40c7e3f871)
@@ -0,0 +1,1284 @@
+/****************************************************************
+ * Copyright (C) 2005 LAMS Foundation (http://lamsfoundation.org)
+ * =============================================================
+ * License Information: http://lamsfoundation.org/licensing/lams/2.0/
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2.0
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 * USA
+ *
+ * http://www.gnu.org/licenses/gpl.txt
+ * ****************************************************************
+ */
+
+/* $Id$ */
+package org.eucm.lams.tool.eadventure.web.action;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Set;
+import java.util.SortedSet;
+import java.util.TreeSet;
+
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import org.apache.commons.beanutils.PropertyUtils;
+import org.apache.commons.lang.StringUtils;
+import org.apache.commons.lang.math.NumberUtils;
+import org.apache.log4j.Logger;
+import org.apache.struts.action.Action;
+import org.apache.struts.action.ActionErrors;
+import org.apache.struts.action.ActionForm;
+import org.apache.struts.action.ActionForward;
+import org.apache.struts.action.ActionMapping;
+import org.apache.struts.action.ActionMessage;
+import org.apache.struts.action.ActionMessages;
+import org.apache.struts.util.LabelValueBean;
+import org.eucm.lams.tool.eadventure.EadventureConstants;
+import org.eucm.lams.tool.eadventure.dto.ExpressionInfo;
+import org.eucm.lams.tool.eadventure.model.EadventureCondition;
+import org.eucm.lams.tool.eadventure.model.EadventureExpression;
+import org.eucm.lams.tool.eadventure.model.EadventureParam;
+import org.eucm.lams.tool.eadventure.util.EadventureConditionComparator;
+import org.eucm.lams.tool.eadventure.util.EadventureExpressionComparator;
+import org.eucm.lams.tool.eadventure.web.form.EadventureConditionForm;
+import org.eucm.lams.tool.eadventure.web.form.EadventureExpressionForm;
+import org.eucm.lams.tool.eadventure.web.form.EadventureForm;
+import org.exolab.castor.util.Iterator;
+import org.lamsfoundation.lams.tool.ToolAccessMode;
+import org.lamsfoundation.lams.util.WebUtil;
+import org.lamsfoundation.lams.web.util.AttributeNames;
+import org.lamsfoundation.lams.web.util.SessionMap;
+import org.springframework.web.context.WebApplicationContext;
+import org.springframework.web.context.support.WebApplicationContextUtils;
+
+/**
+ * Auxiliary action in author mode. It contains operations with EadventureCondition. The rest of operations are located in
+ * AuthoringAction action.
+ *
+ * @author Andrey Balan
+ * @author Angel del Blanco
+ * @see org.eucm.lams.tool.eadventure.web.action.AuthoringAction
+ */
+public class AuthoringEadventureConditionAction extends Action {
+
+ @Override
+ public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request,
+ HttpServletResponse response) throws Exception {
+
+ String param = mapping.getParameter();
+
+ if (param.equals("showConditions")) {
+ return showConditions(mapping, form, request, response);
+ }
+ if (param.equals("newConditionInit")) {
+ return newConditionInit(mapping, form, request, response);
+ }
+ if (param.equals("editCondition")) {
+ return editCondition(mapping, form, request, response);
+ }
+ if (param.equals("saveOrUpdateCondition")) {
+ return saveOrUpdateCondition(mapping, form, request, response);
+ }
+ if (param.equals("removeCondition")) {
+ return removeCondition(mapping, form, request, response);
+ }
+ if (param.equals("newExpressionInit")) {
+ return newExpressionInit(mapping, form, request, response);
+ }
+ if (param.equals("prepareOperatorAndSecondVar")) {
+ return prepareOperatorAndSecondVar(mapping, form, request, response);
+ }
+ if (param.equals("editExpression")) {
+ return editExpression(mapping, form, request, response);
+ }
+ if (param.equals("saveOrUpdateExpression")) {
+ return saveOrUpdateExpression(mapping, form, request, response);
+ }
+ if (param.equals("removeExpression")) {
+ return removeExpression(mapping, form, request, response);
+ }
+ if (param.equals("upCondition")) {
+ return upCondition(mapping, form, request, response);
+ }
+ if (param.equals("downCondition")) {
+ return downCondition(mapping, form, request, response);
+ }
+ if (param.equals("upExpression")) {
+ return upExpression(mapping, form, request, response);
+ }
+ if (param.equals("downExpression")) {
+ return downExpression(mapping, form, request, response);
+ }
+
+ if (param.equals("checkCondition")) {
+ return checkCondition(mapping, form, request, response);
+ }
+
+ if (param.equals("prepareCheckCondition")) {
+ return prepareCheckCondition(mapping, form, request, response);
+ }
+
+
+ return mapping.findForward(EadventureConstants.ERROR);
+ }
+
+ /**
+ * Display same entire authoring page content from HttpSession variable.
+ *
+ * @param mapping
+ * @param form
+ * @param request
+ * @param response
+ * @return
+ * @throws ServletException
+ */
+
+ private ActionForward showConditions(ActionMapping mapping, ActionForm form, HttpServletRequest request,
+ HttpServletResponse response) throws ServletException {
+
+ String sessionMapID = WebUtil.readStrParam(request, EadventureConstants.ATTR_SESSION_MAP_ID);
+ SessionMap sessionMap = (SessionMap) request.getSession().getAttribute(sessionMapID);
+ EadventureForm existForm = (EadventureForm) sessionMap.get(EadventureConstants.ATTR_RESOURCE_FORM);
+
+ EadventureForm eadForm = (EadventureForm) form;
+ try {
+ PropertyUtils.copyProperties(eadForm, existForm);
+ } catch (Exception e) {
+ throw new ServletException(e);
+ }
+
+ ToolAccessMode mode = getAccessMode(request);
+ if (mode.isAuthor()) {
+ return mapping.findForward(EadventureConstants.SUCCESS);
+ } else {
+ return mapping.findForward(EadventureConstants.DEFINE_LATER);
+ }
+ }
+ private ActionForward cleanConditions(ActionMapping mapping, ActionForm form, HttpServletRequest request,
+ HttpServletResponse response) throws ServletException {
+
+ String sessionMapID = WebUtil.readStrParam(request, EadventureConstants.ATTR_SESSION_MAP_ID);
+ SessionMap sessionMap = (SessionMap) request.getSession().getAttribute(sessionMapID);
+ //TODO ver lo de recargar la p�gina
+ //sessionMap.put(EadventureConstants., value)
+ return mapping.findForward(EadventureConstants.SUCCESS);
+ }
+
+
+ /**
+ * Display empty page for new eadventure condition.
+ *
+ * @param mapping
+ * @param form
+ * @param request
+ * @param response
+ * @return
+ */
+ private ActionForward newConditionInit(ActionMapping mapping, ActionForm form, HttpServletRequest request,
+ HttpServletResponse response) {
+
+ String sessionMapID = WebUtil.readStrParam(request, EadventureConstants.ATTR_SESSION_MAP_ID);
+ SessionMap sessionMap = (SessionMap) request.getSession().getAttribute(sessionMapID);
+ // re-init expressionList
+ sessionMap.put(EadventureConstants.ATTR_EXPRESSION_LIST, null);
+
+ // check if some edventure game has been added
+ // it is not necessary, anulo el boton con javascript�
+ //TODO se puede quitar
+ /*ActionErrors errors = new ActionErrors();
+ String hasFile = (String)sessionMap.get(EadventureConstants.ATTR_HAS_FILE);
+ if (!hasFile.equalsIgnoreCase("true"))
+ errors.add(ActionMessages.GLOBAL_MESSAGE, new ActionMessage(
+ EadventureConstants.ERROR_NOT_EAD_ADD));
+
+ if (!errors.isEmpty()) {
+ this.addErrors(request, errors);
+ sessionMap.put(EadventureConstants.ATTR_ERROR_IN_CONDITION, "true");
+ return mapping.findForward("conditions");
+ }*/
+
+ ((EadventureConditionForm) form).setSessionMapID(sessionMapID);
+ //Create expressionList and it into sessionMap, delete if already exists
+ SortedSet expressionList = getEadventureExpressionList(sessionMap);
+ //Add to the session that the condition is not being edited. In case of deleting an expression of this conditions, this expression must be deleted from the
+ //conditions too.
+ sessionMap.put(EadventureConstants.ATTR_EDIT_CONDITION, "false");
+ //TODO se puede quitarjunto con el de arriba
+// sessionMap.put(EadventureConstants.ATTR_ERROR_IN_CONDITION, "false");
+ return mapping.findForward(EadventureConstants.SUCCESS);
+ }
+
+ /**
+ * Display edit page for existed taskList item.
+ *
+ * @param mapping
+ * @param form
+ * @param request
+ * @param response
+ * @return
+ */
+ private ActionForward editCondition(ActionMapping mapping, ActionForm form, HttpServletRequest request,
+ HttpServletResponse response) {
+
+ // get back sessionMAP
+ String sessionMapID = WebUtil.readStrParam(request, EadventureConstants.ATTR_SESSION_MAP_ID);
+ SessionMap sessionMap = (SessionMap) request.getSession().getAttribute(sessionMapID);
+ // re-init expressionList
+ sessionMap.put(EadventureConstants.ATTR_EXPRESSION_LIST, null);
+
+ int position = NumberUtils.stringToInt(request.getParameter(EadventureConstants.PARAM_CONDITION_POSITION), -1);
+ EadventureCondition condition = null;
+ if (position != -1) {
+ SortedSet conditionList = getEadventureConditionList(sessionMap);
+ List rList = new ArrayList(conditionList);
+ condition = rList.get(position);
+ if (condition != null) {
+ ((EadventureConditionForm) form).setName(condition.getName());
+ //TODO va duplicado, creo que mejor solo por atributo
+ ((EadventureConditionForm) form).setExpressionList(condition.getEadListExpression());
+ ((EadventureConditionForm) form).setPosition(String.valueOf(condition.getSequenceId()));
+ SortedSet expressionList = getEadventureExpressionList(sessionMap);
+ expressionList.addAll(condition.getEadListExpression());
+ }
+ }
+ //Add to the session that the condition is being edited. In case of deleting an expression of this conditions, this expression must be deleted from the
+ //conditions too.
+ sessionMap.put(EadventureConstants.ATTR_EDIT_CONDITION, "true");
+ //TODO comprobar el caso null
+ return condition == null ? null : mapping.findForward(EadventureConstants.SUCCESS);
+ }
+
+
+ /**
+ * This method will get necessary information from taskList item form and save or update into
+ * HttpSession TaskListItemList. Notice, this save is not persist them into database, just save
+ * HttpSession temporarily. Only they will be persist when the entire authoring page is being
+ * persisted.
+ *
+ * @param mapping
+ * @param form
+ * @param request
+ * @param response
+ * @return
+ * @throws ServletException
+ */
+ private ActionForward saveOrUpdateCondition(ActionMapping mapping, ActionForm form, HttpServletRequest request,
+ HttpServletResponse response) {
+
+ // get back sessionMAP
+ String sessionMapID = WebUtil.readStrParam(request, EadventureConstants.ATTR_SESSION_MAP_ID);
+ SessionMap sessionMap = (SessionMap) request.getSession().getAttribute(sessionMapID);
+
+ EadventureConditionForm conditionForm = (EadventureConditionForm) form;
+ ActionErrors errors = validateEadventureCondition(conditionForm, request);
+
+ if (!errors.isEmpty()) {
+
+ // expressionList.clear();
+ this.addErrors(request, errors);
+ return mapping.findForward("addcondition");
+ }
+
+ try {
+ extractFormToEadventureCondition(request, conditionForm);
+ } catch (Exception e) {
+ // any upload exception will display as normal error message rather then throw exception directly
+ errors.add(ActionMessages.GLOBAL_MESSAGE, new ActionMessage(EadventureConstants.ERROR_MSG_UPLOAD_FAILED, e
+ .getMessage()));
+ if (!errors.isEmpty()) {
+ //SortedSet expressionList = getEadventureExpressionList(sessionMap);
+ // expressionList.clear();
+ this.addErrors(request, errors);
+ return mapping.findForward("addcondition");
+ }
+ }
+ // set session map ID so that itemlist.jsp can get sessionMAP
+ request.setAttribute(EadventureConstants.ATTR_SESSION_MAP_ID, conditionForm.getSessionMapID());
+ SortedSet expressionList = getEadventureExpressionList(sessionMap);
+ expressionList.clear();
+ // return null to close this window
+ return mapping.findForward(EadventureConstants.SUCCESS);
+ }
+
+ /**
+ * Remove eadventureCondition from HttpSession list and update page display. As authoring rule, all persist only happen
+ * when user submit whole page. So this remove is just impact HttpSession values.
+ *
+ * @param mapping
+ * @param form
+ * @param request
+ * @param response
+ * @return
+ */
+ private ActionForward removeCondition(ActionMapping mapping, ActionForm form, HttpServletRequest request,
+ HttpServletResponse response) {
+
+ // get back sessionMAP
+ String sessionMapID = WebUtil.readStrParam(request, EadventureConstants.ATTR_SESSION_MAP_ID);
+ SessionMap sessionMap = (SessionMap) request.getSession().getAttribute(sessionMapID);
+ // re-init expressionList
+ sessionMap.put(EadventureConstants.ATTR_EXPRESSION_LIST, null);
+
+ int sequenceId = NumberUtils.stringToInt(request.getParameter(EadventureConstants.PARAM_CONDITION_POSITION), -1);
+ if (sequenceId != -1) {
+ SortedSet conditionList = getEadventureConditionList(sessionMap);
+ List rList = new ArrayList(conditionList);
+ EadventureCondition condition = rList.remove(sequenceId);
+ for (EadventureCondition otherCondition : conditionList) {
+ if (otherCondition.getSequenceId() > sequenceId) {
+ otherCondition.setSequenceId(otherCondition.getSequenceId() - 1);
+ }
+ }
+ conditionList.clear();
+ conditionList.addAll(rList);
+ // add to delList
+ List delList = getDeletedEadventureConditionList(sessionMap);
+ delList.add(condition);
+ }
+ request.setAttribute(EadventureConstants.ATTR_SESSION_MAP_ID, sessionMapID);
+ return mapping.findForward(EadventureConstants.SUCCESS);
+ }
+
+
+ /**
+ * Move up current condition.
+ *
+ * @param mapping
+ * @param form
+ * @param request
+ * @param response
+ * @return
+ */
+ private ActionForward upCondition(ActionMapping mapping, ActionForm form, HttpServletRequest request,
+ HttpServletResponse response) {
+ return switchCondition(mapping, request, true);
+ }
+
+ /**
+ * Move down current Condition.
+ *
+ * @param mapping
+ * @param form
+ * @param request
+ * @param response
+ * @return
+ */
+ private ActionForward downCondition(ActionMapping mapping, ActionForm form, HttpServletRequest request,
+ HttpServletResponse response) {
+ return switchCondition(mapping, request, false);
+ }
+
+
+
+ /**
+ * Move up current Expression.
+ *
+ * @param mapping
+ * @param form
+ * @param request
+ * @param response
+ * @return
+ */
+ private ActionForward upExpression(ActionMapping mapping, ActionForm form, HttpServletRequest request,
+ HttpServletResponse response) {
+ //TODO quitar el ultimo parametro
+ return switchExpression(mapping, request, true, 0);
+ }
+
+ /**
+ * Move down current Expression.
+ *
+ * @param mapping
+ * @param form
+ * @param request
+ * @param response
+ * @return
+ */
+ private ActionForward downExpression(ActionMapping mapping, ActionForm form, HttpServletRequest request,
+ HttpServletResponse response) {
+ //TODO quitar el ultimo parametro
+ return switchExpression(mapping, request, false, 0);
+ }
+
+
+
+ /**
+ * Display empty page for new eadventure expression.
+ *
+ * @param mapping
+ * @param form
+ * @param request
+ * @param response
+ * @return
+ */
+ private ActionForward newExpressionInit(ActionMapping mapping, ActionForm form, HttpServletRequest request,
+ HttpServletResponse response) {
+
+ String sessionMapID = WebUtil.readStrParam(request, EadventureConstants.ATTR_SESSION_MAP_ID);
+ ((EadventureExpressionForm) form).setSessionMapID(sessionMapID);
+ populateFormWithPossibleVariables(form, request);
+
+ return mapping.findForward(EadventureConstants.SUCCESS);
+ }
+
+ /**
+ * Prepare the operator and the second var of the expression taking into account the type of the first var
+ *
+ * @param mapping
+ * @param form
+ * @param request
+ * @param response
+ * @return
+ */
+ private ActionForward prepareOperatorAndSecondVar(ActionMapping mapping, ActionForm form, HttpServletRequest request,
+ HttpServletResponse response) {
+
+ String sessionMapID = WebUtil.readStrParam(request, EadventureConstants.ATTR_SESSION_MAP_ID);
+ SessionMap sessionMap = (SessionMap) request.getSession().getAttribute(sessionMapID);
+
+ EadventureExpressionForm expForm = ((EadventureExpressionForm) form);
+ expForm.setSessionMapID(sessionMapID);
+ // conserve the all possible varsOp1
+ populateFormWithPossibleVariables(form, request);
+ // fill the form with the selected value
+ expForm.setSelectedVarOp1(WebUtil.readStrParam(request, EadventureConstants.PARAM_VAR_NAME));
+ // now fill the other list of elements taking into account the value selected in the authoringView for the firstOp
+ List listParams = this.getEadventureParamList(sessionMap);
+ String name = WebUtil.readStrParam(request, EadventureConstants.PARAM_VAR_NAME);
+ int selectedVarType = prepareOpAndVarFromType(form,name, listParams);
+ // get the position
+ String position = request.getParameter(EadventureConstants.PARAM_EXPRESSION_POSITION);
+ ((EadventureExpressionForm)form).setPosition(position);
+ ((EadventureExpressionForm)form).setNextOp("and");
+ sessionMap.put(EadventureConstants.ATTR_EXPR_SELECTED_TYPE, selectedVarType);
+
+ return mapping.findForward(EadventureConstants.SUCCESS);
+ }
+ /**
+ * Prepare the operator and the second var of the expression taking into account the type of the first var
+ *
+ * @param mapping
+ * @param form
+ * @param request
+ * @param response
+ * @return
+ */
+ private ActionForward editExpression(ActionMapping mapping, ActionForm form, HttpServletRequest request,
+ HttpServletResponse response) {
+
+ int selectedVarType=-1;
+ // get back sessionMAP
+ String sessionMapID = WebUtil.readStrParam(request, EadventureConstants.ATTR_SESSION_MAP_ID);
+ SessionMap sessionMap = (SessionMap) request.getSession().getAttribute(sessionMapID);
+ populateFormWithPossibleVariables(form, request);
+
+ int position = NumberUtils.stringToInt(request.getParameter(EadventureConstants.PARAM_EXPRESSION_POSITION), -1);
+ EadventureExpression expression= null;
+ if (position != -1) {
+ // List expressionList = this.getListFromSession(sessionMap, EadventureConstants.ATTR_EXPRESSION_LIST);
+ SortedSet expressionList = getEadventureExpressionList(sessionMap);
+ List rList = new ArrayList(expressionList);
+ ((EadventureExpressionForm)form).setPosition(String.valueOf(position));
+ List listParams = this.getEadventureParamList(sessionMap);
+ expression = rList.get(position);
+ if (expression != null) {
+ //TODO repasar si merece la pena hacerlo asi o meter algo mas de info sobre los parametros en el form!!!!
+ selectedVarType = prepareOpAndVarFromType(form,expression.getFirstOp().getName(), listParams);
+ ((EadventureExpressionForm)form).setSelectedVarOp1(String.valueOf(expression.getFirstOp().getName()));
+ ((EadventureExpressionForm)form).setSelectedOperator(expression.getExpresionOp());
+ if (expression.getValueIntroduced()==null){
+ ((EadventureExpressionForm)form).setSelectedVarOp2(String.valueOf(expression.getVarIntroduced().getName()));
+ ((EadventureExpressionForm)form).setIntroducedValue(null);
+ ((EadventureExpressionForm)form).setSecondVarSelected(true);
+
+ }else{
+ ((EadventureExpressionForm)form).setIntroducedValue(expression.getValueIntroduced());
+ ((EadventureExpressionForm)form).setSelectedVarOp2(null);
+ ((EadventureExpressionForm)form).setSecondVarSelected(false);
+ }
+ }
+ }
+ ((EadventureExpressionForm)form).setNextOp("and");
+
+ sessionMap.put(EadventureConstants.ATTR_EXPR_SELECTED_TYPE, selectedVarType);
+
+ return mapping.findForward(EadventureConstants.SUCCESS);
+
+ }
+
+ /**
+ * This method will get necessary information from taskList item form and save or update into
+ * HttpSession TaskListItemList. Notice, this save is not persist them into database, just save
+ * HttpSession temporarily. Only they will be persist when the entire authoring page is being
+ * persisted.
+ *
+ * @param mapping
+ * @param form
+ * @param request
+ * @param response
+ * @return
+ * @throws ServletException
+ */
+ private ActionForward saveOrUpdateExpression(ActionMapping mapping, ActionForm form, HttpServletRequest request,
+ HttpServletResponse response) {
+
+
+ String sessionMapID = WebUtil.readStrParam(request, EadventureConstants.ATTR_SESSION_MAP_ID);
+ SessionMap sessionMap = (SessionMap) request.getSession().getAttribute(sessionMapID);
+
+ EadventureExpressionForm expressionForm = (EadventureExpressionForm) form;
+ ActionErrors errors = validateEadventureExpression(expressionForm, request);
+
+ if (!errors.isEmpty()) {
+ populateFormWithPossibleVariables(form, request);
+ if (errors.get("no-op").hasNext()){
+ //TODO nuevo metodo, no tiene sentido pasar todo esto!!!!
+ List listParams = this.getEadventureParamList(sessionMap);
+ String name = expressionForm.getSelectedVarOp1();
+ int selectedVarType = prepareOpAndVarFromType(expressionForm,name, listParams);
+ expressionForm.setNextOp("and");
+ }
+
+ this.addErrors(request, errors);
+ return mapping.findForward("addexpression");
+ }
+ try {
+ extractFormToEadventureExpression(request, expressionForm);
+ } catch (Exception e) {
+ // any upload exception will display as normal error message rather then throw exception directly
+ errors.add(ActionMessages.GLOBAL_MESSAGE, new ActionMessage(EadventureConstants.ERROR_MSG_NO_EXPRESSIONS, e
+ .getMessage()));
+ if (!errors.isEmpty()) {
+ populateFormWithPossibleVariables(form, request);
+ this.addErrors(request, errors);
+ return mapping.findForward("addexpression");
+ }
+ }
+ // set session map ID so that itemlist.jsp can get sessionMAP
+ request.setAttribute(EadventureConstants.ATTR_SESSION_MAP_ID, expressionForm.getSessionMapID());
+ // return null to close this window
+ return mapping.findForward(EadventureConstants.SUCCESS);
+ }
+
+ /**
+ * Remove eadventureExpression from HttpSession list and update page display. As authoring rule, all persist only happen
+ * when user submit whole page. So this remove is just impact HttpSession values.
+ *
+ * @param mapping
+ * @param form
+ * @param request
+ * @param response
+ * @return
+ */
+ private ActionForward removeExpression(ActionMapping mapping, ActionForm form, HttpServletRequest request,
+ HttpServletResponse response) {
+
+ // get back sessionMAP
+ String sessionMapID = WebUtil.readStrParam(request, EadventureConstants.ATTR_SESSION_MAP_ID);
+ SessionMap sessionMap = (SessionMap) request.getSession().getAttribute(sessionMapID);
+
+ int position = NumberUtils.stringToInt(request.getParameter(EadventureConstants.PARAM_EXPRESSION_POSITION), -1);
+ if (position != -1) {
+ SortedSet expressionList = getEadventureExpressionList(sessionMap);
+ List rList = new ArrayList(expressionList);
+ EadventureExpression expression = rList.remove(position);
+ for (EadventureExpression otherExpression : expressionList) {
+ if (otherExpression.getSequenceId() > position) {
+ otherExpression.setSequenceId(otherExpression.getSequenceId() - 1);
+ }
+ }
+ // actualize the expressionList in sessionMap
+ expressionList.clear();
+ expressionList.addAll(rList);
+ // add to delList
+ List delList = getDeletedEadventureExpressionList(sessionMap);
+ delList.add(expression);
+ // TODO preguntar si esto es necesario, quiz�s no interesa si no lo damos a salvar!!!!!!!!!!!!!!!!!!!
+ //check if we need delete this expression from a condition in conditions list
+ /* boolean isConditionEdit = Boolean.getBoolean((String)sessionMap.get(EadventureConstants.ATTR_EDIT_CONDITION));
+ if (isConditionEdit){
+ // get the condition in condition list
+ SortedSet conditionList = getEadventureConditionList(sessionMap);
+ List cList = new ArrayList(conditionList);
+ int positionCondition = Integer.parseInt(((EadventureConditionForm)form).getPosition());
+ EadventureCondition condition = cList.get(positionCondition);
+ if (condition != null) {
+ condition.setEadListExpression(expressionList);
+ ((EadventureConditionForm)form).setExpressionList(expressionList);
+ //TODO borrar si esta bien lo anterior
+ /*Set expressionFromConditionList = condition.getEadListExpression();
+ List ecList = new ArrayList(expressionFromConditionList);
+ ecList.remove(expression);
+ //actualize the expression list in the condition in the conditionsList in the sessionMap
+ expressionFromConditionList.clear();
+ expressionFromConditionList.addAll(ecList);
+ ////TODO quitar, creo que no hace falta actualize the expressionList in conditionForm
+
+ }
+ }*/
+ }
+
+ request.setAttribute(EadventureConstants.ATTR_SESSION_MAP_ID, sessionMapID);
+ return mapping.findForward(EadventureConstants.SUCCESS);
+ }
+
+
+ /**
+ * Prepare the operator and the second var of the expression taking into account the type of the first var
+ *
+ * @param mapping
+ * @param form
+ * @param request
+ * @param response
+ * @return
+ */
+ private ActionForward prepareCheckCondition(ActionMapping mapping, ActionForm form, HttpServletRequest request,
+ HttpServletResponse response) {
+
+ // get back sessionMAP
+ String sessionMapID = WebUtil.readStrParam(request, EadventureConstants.ATTR_SESSION_MAP_ID);
+ SessionMap sessionMap = (SessionMap) request.getSession().getAttribute(sessionMapID);
+
+ SortedSet expressionList = getEadventureExpressionList(sessionMap);
+ List exprList = new ArrayList(expressionList);
+ String description = new String();
+ java.util.Iterator it = exprList.iterator();
+ List params = this.getEadventureParamList(sessionMap);
+ // prepare the data structures to send to jsp
+ ArrayList expressionsInfo = new ArrayList();
+ while(it.hasNext()){
+ EadventureExpression expr = it.next();
+ ExpressionInfo exprInfo = null;
+ // identify the variable
+ String name = expr.getFirstOp().getName();
+ String type = expr.getFirstOp().getType();
+ String operator = expr.getExpresionOp();
+ String nextOp = expr.getNextOp();
+ exprInfo = new ExpressionInfo(name,type,operator,nextOp);
+ if (expr.getValueIntroduced()!=null)
+ exprInfo.setValueInExpression(expr.getValueIntroduced());
+ else
+ exprInfo.setNameSecondOp(expr.getVarIntroduced().getName());
+
+ expressionsInfo.add(exprInfo);
+
+ }
+
+ sessionMap.put(EadventureConstants.ATTR_EXPRS_INFO, expressionsInfo);
+ sessionMap.put(EadventureConstants.ATTR_EXPRS_INFO, expressionsInfo);
+ sessionMap.put(EadventureConstants.ATTR_EXPRS_INFO, expressionsInfo);
+
+ return mapping.findForward(EadventureConstants.SUCCESS);
+ }
+
+ /**
+ * Prepare the operator and the second var of the expression taking into account the type of the first var
+ *
+ * @param mapping
+ * @param form
+ * @param request
+ * @param response
+ * @return
+ */
+ private ActionForward checkCondition(ActionMapping mapping, ActionForm form, HttpServletRequest request,
+ HttpServletResponse response) {
+
+ return mapping.findForward(EadventureConstants.SUCCESS);
+ }
+
+
+
+ // *************************************************************************************
+ // Private methods for internal needs
+ // *************************************************************************************
+ private ActionForward switchCondition(ActionMapping mapping, HttpServletRequest request, boolean up) {
+ // get back sessionMAP
+ String sessionMapID = WebUtil.readStrParam(request, EadventureConstants.ATTR_SESSION_MAP_ID);
+ SessionMap sessionMap = (SessionMap) request.getSession().getAttribute(sessionMapID);
+
+ int sequenceId = NumberUtils.stringToInt(request.getParameter(EadventureConstants.PARAM_CONDITION_POSITION), -1);
+ if (sequenceId != -1) {
+ SortedSet conditionList = getEadventureConditionList(sessionMap);
+ List rList = new ArrayList(conditionList);
+ // get current and the target condition, and switch their sequnece
+ EadventureCondition condition = rList.get(sequenceId);
+ EadventureCondition repCondition;
+ if (up) {
+ repCondition = rList.get(--sequenceId);
+ } else {
+ repCondition = rList.get(++sequenceId);
+ }
+ int upSeqId = repCondition.getSequenceId();
+ repCondition.setSequenceId(condition.getSequenceId());
+ condition.setSequenceId(upSeqId);
+
+ // put back list, it will be sorted again
+ conditionList.clear();
+ conditionList.addAll(rList);
+ }
+
+ request.setAttribute(EadventureConstants.ATTR_SESSION_MAP_ID, sessionMapID);
+ return mapping.findForward(EadventureConstants.SUCCESS);
+ }
+
+ private ActionForward switchExpression(ActionMapping mapping, HttpServletRequest request, boolean up, int conditionPosition) {
+ // get back sessionMAP
+ String sessionMapID = WebUtil.readStrParam(request, EadventureConstants.ATTR_SESSION_MAP_ID);
+ SessionMap sessionMap = (SessionMap) request.getSession().getAttribute(sessionMapID);
+
+ int sequenceId = NumberUtils.stringToInt(request.getParameter(EadventureConstants.PARAM_EXPRESSION_POSITION), -1);
+ if (sequenceId != -1) {
+ SortedSet expressionList = getEadventureExpressionList(sessionMap);
+ List rList = new ArrayList(expressionList);
+ // get current and the target item, and switch their sequnece
+ EadventureExpression expression = rList.get(sequenceId);
+ EadventureExpression repExpression;
+ if (up) {
+ repExpression = rList.get(--sequenceId);
+ } else {
+ repExpression = rList.get(++sequenceId);
+ }
+ int upSeqId = repExpression.getSequenceId();
+ repExpression.setSequenceId(expression.getSequenceId());
+ expression.setSequenceId(upSeqId);
+ // put back list, it will be sorted again
+ expressionList.clear();
+ expressionList.addAll(rList);
+
+ // TODO comprobar si esto es necesario, quiz�s no interesa si no le doy a salvar!!!!!!!!!!!!!!!!!!!!!!!!!!
+ //check if we need delete this expression from a condition in conditions list
+ /* boolean isConditionEdit = Boolean.getBoolean((String)sessionMap.get(EadventureConstants.ATTR_EDIT_CONDITION));
+ if (isConditionEdit){
+ // get the condition in condition list
+ SortedSet conditionList = getEadventureConditionList(sessionMap);
+ List cList = new ArrayList(conditionList);
+ EadventureCondition condition = cList.get(conditionPosition);
+ if (condition != null) {
+ condition.setEadListExpression(expressionList);
+ //TODO borrar si sobra!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!1
+ /*Set expressionFromConditionList = condition.getEadListExpression();
+ List ecList = new ArrayList(expressionFromConditionList);
+ ecList.remove(expression);
+ //actualize the expression list in the condition in the conditionsList in the sessionMap
+ expressionFromConditionList.clear();
+ expressionFromConditionList.addAll(ecList);
+
+ }
+ }*/
+ }
+
+ request.setAttribute(EadventureConstants.ATTR_SESSION_MAP_ID, sessionMapID);
+ return mapping.findForward(EadventureConstants.SUCCESS);
+ }
+
+ // returns the int value to save in sessionMap to know in jsp which type is the selected variable
+ private int prepareOpAndVarFromType(ActionForm form, String varName, List listParams){
+
+ int returnType=-1;
+ // search the type of the param
+ java.util.Iterator it = listParams.iterator();
+ EadventureParam param = null;
+ String type=null;
+ while (it.hasNext()){
+ param = it.next();
+ if (param.getName().equals(varName)){
+ type = param.getType();
+ }
+ }
+
+ String[] operators=null;
+ if (type.equals("integer")){
+ // Initialize the operator .
+ returnType=0;
+ operators = EadventureConstants.IntergerOp;
+ ((EadventureExpressionForm) form).setIntroducedValue("0");
+ } else if (type.equals("string")){
+ returnType=1;
+ operators = EadventureConstants.StringOp;
+
+ } else if (type.equals("boolean")){
+ returnType=2;
+ operators = EadventureConstants.BooleanOp;
+ }
+ ((EadventureExpressionForm) form).setPossibleOperator(operators);
+
+ // prepare the second var taking into account the type of first param
+ String[] params = prepareListOfParams(listParams,type,varName);
+ ((EadventureExpressionForm) form).setPossibleVarsOp2(params);
+
+ return returnType;
+ }
+
+
+
+
+ /**
+ * Return the LabelValueBean list of all the params filter by type.
+ * If type is "none", this method takes all the params.
+ *
+ * @param list
+ * @param type
+ * @return
+ */
+ private String[] prepareListOfParams(List list, String type, String name){
+ // Initialise the LabelValueBeans in the possibleOptions array.
+ //TODO como para el caso de un tipo espec�fico no sabemos cual va a ser el tama�o del array, mejor usa run arrayListparcial y luego
+ // pasarlo a array normal
+
+ ArrayList paramAux = new ArrayList();
+ for (EadventureParam param : list) {
+ //if type is none means that we want to add all params
+ if (type.equals("none")||(type.equals(param.getType()) && !name.equals(param.getName()) ))
+ paramAux.add(param.getName());
+ }
+
+ return paramAux.toArray(new String[paramAux.size()]);
+ }
+
+ private String[] prepareListOfParams(List list){
+ return prepareListOfParams(list,"none","");
+ }
+
+
+ /**
+ * Return TaskListService bean.
+ */
+ /* private ITaskListService getTaskListService() {
+ WebApplicationContext wac = WebApplicationContextUtils.getRequiredWebApplicationContext(getServlet()
+ .getServletContext());
+ return (ITaskListService) wac.getBean(TaskListConstants.RESOURCE_SERVICE);
+ }
+
+ /**
+ * List save current taskList items.
+ *
+ * @param request
+ * @return
+ */
+ /* private SortedSet getTaskListConditionList(SessionMap sessionMap) {
+ SortedSet list = (SortedSet) sessionMap
+ .get(TaskListConstants.ATTR_CONDITION_LIST);
+ if (list == null) {
+ list = new TreeSet(new TaskListConditionComparator());
+ sessionMap.put(TaskListConstants.ATTR_CONDITION_LIST, list);
+ }
+ return list;
+ }
+
+
+
+ /**
+ * List save deleted taskList items, which could be persisted or non-persisted items.
+ *
+ * @param request
+ * @return
+ */
+ private List getDeletedEadventureConditionList(SessionMap sessionMap) {
+ return getListFromSession(sessionMap, EadventureConstants.ATTR_DELETED_CONDITION_LIST);
+ }
+
+
+ /**
+ * List save deleted taskList items, which could be persisted or non-persisted items.
+ *
+ * @param request
+ * @return
+ */
+ private List getDeletedEadventureExpressionList(SessionMap sessionMap) {
+ return getListFromSession(sessionMap, EadventureConstants.ATTR_DELETED_EXPRESSION_LIST);
+ }
+
+ /**
+ * Get java.util.List from HttpSession by given name.
+ *
+ * @param request
+ * @param name
+ * @return
+ */
+ private List getListFromSession(SessionMap sessionMap, String name) {
+ List list = (List) sessionMap.get(name);
+ if (list == null) {
+ list = new ArrayList();
+ sessionMap.put(name, list);
+ }
+ return list;
+ }
+
+ /**
+ * This method will populate eadventure expression vars information to its form for edit use (for first param).
+ *
+ * @param sequenceId
+ * @param condition
+ * @param form
+ * @param request
+ */
+ private void populateFormWithPossibleVariables(ActionForm form, HttpServletRequest request) {
+
+ // get back sessionMAP
+ String sessionMapID = WebUtil.readStrParam(request, EadventureConstants.ATTR_SESSION_MAP_ID);
+ SessionMap sessionMap = (SessionMap) request.getSession().getAttribute(sessionMapID);
+ EadventureExpressionForm eadForm = ((EadventureExpressionForm) form);
+ List paramsList = getEadventureParamList(sessionMap);
+
+
+ // Initialise the options in the possibleOptions array.
+ String[] params = prepareListOfParams(paramsList);
+ eadForm.setPossibleVarsOp1(params);
+
+ }
+
+
+ /**
+ * List save current eadventure params.
+ *
+ * @param sessionMap
+ * @return
+ */
+
+ private List getEadventureParamList(SessionMap sessionMap) {
+ return getListFromSession(sessionMap, EadventureConstants.ATTR_PARAMS_LIST);
+ }
+
+ /**
+ * List save current eadventure conditions.
+ *
+ * @param request
+ * @return
+ */
+ private SortedSet getEadventureConditionList(SessionMap sessionMap) {
+ SortedSet list = (SortedSet) sessionMap
+ .get(EadventureConstants.ATTR_CONDITION_LIST);
+ if (list == null) {
+ list = new TreeSet(new EadventureConditionComparator());
+ sessionMap.put(EadventureConstants.ATTR_CONDITION_LIST, list);
+ }
+ return list;
+ }
+
+ private SortedSet getEadventureExpressionList(SessionMap sessionMap) {
+ SortedSet list = (SortedSet) sessionMap
+ .get(EadventureConstants.ATTR_EXPRESSION_LIST);
+ if (list == null) {
+ list = new TreeSet(new EadventureExpressionComparator());
+ sessionMap.put(EadventureConstants.ATTR_EXPRESSION_LIST, list);
+ }
+ return list;
+ }
+
+
+
+ /**
+ * Extract form content to eadventureCondition.
+ *
+ * @param request
+ * @param form
+ * @throws TaskListException
+ */
+ private void extractFormToEadventureCondition(HttpServletRequest request, EadventureConditionForm form)
+ throws Exception {
+ /*
+ * BE CAREFUL: This method will copy necessary info from request form to a old or new TaskListItem instance. It
+ * gets all info EXCEPT TaskListItem.createDate and TaskListItem.createBy, which need be set when persisting
+ * this taskList item.
+ */
+
+ SessionMap sessionMap = (SessionMap) request.getSession().getAttribute(form.getSessionMapID());
+ // check whether it is "edit(old item)" or "add(new item)"
+ SortedSet conditionList = getEadventureConditionList(sessionMap);
+ int position = NumberUtils.stringToInt(request.getParameter(EadventureConstants.PARAM_CONDITION_POSITION), -1);
+ EadventureCondition condition = null;
+
+ if (position == -1) { // add
+ condition = new EadventureCondition();
+ int maxSeq = 0;
+ if (conditionList != null && conditionList.size() > 0) {
+ EadventureCondition last = conditionList.last();
+ maxSeq = last.getSequenceId() + 1;
+ }
+ condition.setSequenceId(maxSeq);
+ conditionList.add(condition);
+ } else { // edit
+ List rList = new ArrayList(conditionList);
+ condition = rList.get(position);
+ }
+
+ condition.setName(form.getName());
+
+ SortedSet expressionList = getEadventureExpressionList(sessionMap);
+ // set the condition as parent of all expressions
+ List eList = new ArrayList(expressionList);
+ java.util.Iterator it = eList.iterator();
+ while(it.hasNext()){
+ EadventureExpression eadExpr = it.next();
+ eadExpr.setCondition(condition);
+ }
+ condition.setEadListExpression(expressionList);
+ // re-init expressionList
+ sessionMap.put(EadventureConstants.ATTR_EXPRESSION_LIST, null);
+
+ }
+
+
+ /**
+ * Extract form content to eadventureExpression.
+ *
+ * @param request
+ * @param form
+ * @throws TaskListException
+ */
+ private void extractFormToEadventureExpression(HttpServletRequest request, EadventureExpressionForm form)
+ throws Exception {
+ /*
+ * BE CAREFUL: This method will copy necessary info from request form to a old or new TaskListItem instance. It
+ * gets all info EXCEPT TaskListItem.createDate and TaskListItem.createBy, which need be set when persisting
+ * this taskList item.
+ */
+
+
+ SessionMap sessionMap = (SessionMap) request.getSession().getAttribute(form.getSessionMapID());
+ // check whether it is "edit(old item)" or "add(new item)"
+ SortedSet expressionList = getEadventureExpressionList(sessionMap);
+ //int position = NumberUtils.stringToInt(request.getParameter(EadventureConstants.PARAM_EXPRESSION_POSITION), -1);
+ int position = NumberUtils.stringToInt(((EadventureExpressionForm)form).getPosition());
+ EadventureExpression expression = null;
+
+ if (position == -1) { // add
+ expression = new EadventureExpression();
+ int maxSeq = 0;
+ if (expression != null && expressionList.size() > 0) {
+ EadventureExpression last = expressionList.last();
+ maxSeq = last.getSequenceId() + 1;
+ }
+ expression.setSequenceId(maxSeq);
+ expressionList.add(expression);
+ } else { // edit
+ List rList = new ArrayList(expressionList);
+ expression = rList.get(position);
+ }
+
+ List paramList = this.getEadventureParamList(sessionMap);
+ expression.setFirstOp(getParam(form.getSelectedVarOp1(),paramList));
+ expression.setExpresionOp(form.getSelectedOperator());
+
+
+
+ if (form.isSecondVarSelected()){
+ expression.setVarIntroduced(getParam(form.getSelectedVarOp2(),paramList));
+ expression.setValueIntroduced(null);
+ }else{
+ expression.setValueIntroduced(form.getIntroducedValue());
+ expression.setVarIntroduced(null);
+ }
+ expression.setNextOp(form.getNextOp());
+
+ }
+
+ private EadventureParam getParam(String name, List list){
+
+ java.util.Iterator it = list.iterator();
+ while(it.hasNext()){
+ EadventureParam param = it.next();
+ if (param.getName().equals(name))
+ return param;
+ }
+ return null;
+ }
+
+ /**
+ * Validate EadventureCondition
+ *
+ * @param conditionForm
+ * @return
+ */
+ private ActionErrors validateEadventureCondition(EadventureConditionForm conditionForm, HttpServletRequest request) {
+ ActionErrors errors = new ActionErrors();
+ String sessionMapID = conditionForm.getSessionMapID();
+ SessionMap sessionMap = (SessionMap) request.getSession().getAttribute(sessionMapID);
+
+ String formConditionName = conditionForm.getName();
+ if (StringUtils.isBlank(formConditionName)) {
+ errors.add(ActionMessages.GLOBAL_MESSAGE, new ActionMessage(EadventureConstants.ERROR_NAME_CONDITION_BLANK));
+ } else if (StringUtils.contains(formConditionName, '#')) {
+ errors.add(ActionMessages.GLOBAL_MESSAGE, new ActionMessage(
+ EadventureConstants.ERROR_MSG_NAME_CONTAINS_WRONG_SYMBOL));
+ } else {
+
+ String formConditionSequenceId = conditionForm.getPosition();
+ SortedSet conditionList = getEadventureConditionList(sessionMap);
+ for (EadventureCondition condition : conditionList) {
+ if (formConditionName.equals(condition.getName())
+ && !formConditionSequenceId.equals((new Integer(condition.getSequenceId())).toString())) {
+ errors.add(ActionMessages.GLOBAL_MESSAGE, new ActionMessage(
+ EadventureConstants.ERROR_MSG_NAME_DUPLICATED));
+ break;
+ }
+ }
+ }
+
+ // should be created at least one expression
+ //Set expressionList = conditionForm.getExpressionList();
+ Set expressionList = getEadventureExpressionList(sessionMap);
+ if (expressionList == null || expressionList.size() == 0) {
+ errors
+ .add(ActionMessages.GLOBAL_MESSAGE, new ActionMessage(
+ EadventureConstants.ERROR_MSG_NO_EXPRESSIONS));
+ }
+
+ return errors;
+ }
+
+
+ /**
+ * Validate EadventureCondition
+ *
+ * @param conditionForm
+ * @return
+ */
+ private ActionErrors validateEadventureExpression(EadventureExpressionForm expressionForm, HttpServletRequest request) {
+ ActionErrors errors = new ActionErrors();
+
+ /*String formEaxpressionName = expressionForm.getName();
+ if (StringUtils.isBlank(formEaxpressionName)) {
+ errors.add(ActionMessages.GLOBAL_MESSAGE, new ActionMessage(EadventureConstants.ERROR_NAME_CONDITION_BLANK));
+ } else if (StringUtils.contains(formEaxpressionName, '#')) {
+ errors.add(ActionMessages.GLOBAL_MESSAGE, new ActionMessage(
+ EadventureConstants.ERROR_MSG_NAME_CONTAINS_WRONG_SYMBOL));
+ } else {*/
+
+// StringUtils.isNumeric(arg0)
+// StringUtils.
+ //TODO revisar, muchas de estas cosas no se permiten en la vista, por lo que no hace falta comprbarlas aqui
+ String formExpressionSequenceId = expressionForm.getPosition();
+
+ String sessionMapID = expressionForm.getSessionMapID();
+ SessionMap sessionMap = (SessionMap) request.getSession().getAttribute(sessionMapID);
+ String firstVar = expressionForm.getSelectedVarOp1();
+ List paramList = this.getEadventureParamList(sessionMap);
+ String type = null;
+ for (EadventureParam param: paramList){
+ if (param.getName().equals(firstVar))
+ type = param.getType();
+ }
+
+ if (firstVar.equals("no-option")){
+ errors.add(ActionMessages.GLOBAL_MESSAGE, new ActionMessage(EadventureConstants.ERROR__EXPRESSION_NO_FIRST_VAR));
+ }else {
+
+ if (expressionForm.getSelectedVarOp2()!=null&&!expressionForm.getSelectedVarOp2().equals("")){
+ //validate selected var
+ String secondVar = expressionForm.getSelectedVarOp2();
+ if (firstVar.equals(secondVar))
+ errors.add(ActionMessages.GLOBAL_MESSAGE, new ActionMessage(EadventureConstants.ERROR_SAME_VARS_NAME));
+ else{
+ String type2 = null;
+ for (EadventureParam param: paramList){
+ if (param.getName().equals(firstVar))
+ type2 = param.getType();
+ }
+ if (type!=null){
+ if (!type2.equals(type))
+ errors.add(ActionMessages.GLOBAL_MESSAGE, new ActionMessage(EadventureConstants.ERROR_NOT_EQ_VARS_TYPE));
+ }
+ }
+
+ } else if (expressionForm.getIntroducedValue()!=null&&!expressionForm.getIntroducedValue().endsWith("")){
+ //Validate introduced value
+
+ String introducedValue = expressionForm.getIntroducedValue();
+ if (StringUtils.isBlank(introducedValue)) {
+ errors.add(ActionMessages.GLOBAL_MESSAGE, new ActionMessage(EadventureConstants.ERROR_NAME_CONDITION_BLANK));
+ } else if (StringUtils.contains(introducedValue, '#')) {
+ errors.add(ActionMessages.GLOBAL_MESSAGE, new ActionMessage(
+ EadventureConstants.ERROR_MSG_NAME_CONTAINS_WRONG_SYMBOL));
+ } else {
+ if (type!=null){
+ if (type.equals("string")){
+ if (StringUtils.isBlank(introducedValue)) {
+ errors.add(ActionMessages.GLOBAL_MESSAGE, new ActionMessage(EadventureConstants.ERROR_NAME_VALUE_BLANK));
+ } else if (!StringUtils.isAlpha(introducedValue))
+ errors.add(ActionMessages.GLOBAL_MESSAGE, new ActionMessage(EadventureConstants.ERROR_VALUE_NOT_ALPHA));
+
+ }else if (type.equals("integer")){
+ if (StringUtils.isBlank(introducedValue)) {
+ errors.add(ActionMessages.GLOBAL_MESSAGE, new ActionMessage(EadventureConstants.ERROR_NAME_VALUE_BLANK));
+ } else if (!StringUtils.isNumeric(introducedValue))
+ errors.add(ActionMessages.GLOBAL_MESSAGE, new ActionMessage(EadventureConstants.ERROR_VALUE_NOT_NUMERIC));
+ } else if (type.equals("boolean")){
+ if (StringUtils.isBlank(introducedValue)) {
+ errors.add(ActionMessages.GLOBAL_MESSAGE, new ActionMessage(EadventureConstants.ERROR_NAME_VALUE_BLANK));
+ } else if (!introducedValue.equalsIgnoreCase("true")||!introducedValue.equalsIgnoreCase("false")){
+ errors.add(ActionMessages.GLOBAL_MESSAGE, new ActionMessage(EadventureConstants.ERROR_VALUE_NOT_BOOLEAN));
+
+ }
+ }
+ } else {
+ //TODO caso en que el type no es ninguno de los anteriores
+ }
+ }
+ }
+
+ if (expressionForm.getSelectedOperator()!=null&&expressionForm.getSelectedOperator().equals("no-option")){
+ errors.add("no-op", new ActionMessage(EadventureConstants.ERROR__EXPRESSION_NO_OPERATOR));
+ }else if (expressionForm.isSecondVarSelected() && expressionForm.getSelectedVarOp2().equals("no-option")){
+ errors.add("no-op", new ActionMessage(EadventureConstants.ERROR__EXPRESSION_NO_SECOND_VAR));
+ }
+ }
+
+ return errors;
+ }
+
+
+
+
+ /**
+ * Get ToolAccessMode from HttpRequest parameters. Default value is AUTHOR mode.
+ *
+ * @param request
+ * @return
+ */
+ private ToolAccessMode getAccessMode(HttpServletRequest request) {
+ ToolAccessMode mode;
+ String modeStr = request.getParameter(AttributeNames.ATTR_MODE);
+ if (StringUtils.equalsIgnoreCase(modeStr, ToolAccessMode.TEACHER.toString())) {
+ mode = ToolAccessMode.TEACHER;
+ } else {
+ mode = ToolAccessMode.AUTHOR;
+ }
+ return mode;
+ }
+
+ /*private ActionMessages validate(TaskListForm taskListForm, ActionMapping mapping, HttpServletRequest request) {
+ ActionMessages errors = new ActionMessages();
+ // if (StringUtils.isBlank(taskListForm.getTaskList().getTitle())) {
+ // ActionMessage error = new ActionMessage("error.resource.item.title.blank");
+ // errors.add(ActionMessages.GLOBAL_MESSAGE, error);
+ // }
+
+ // define it later mode(TEACHER) skip below validation.
+ String modeStr = request.getParameter(AttributeNames.ATTR_MODE);
+ if (StringUtils.equals(modeStr, ToolAccessMode.TEACHER.toString())) {
+ return errors;
+ }
+
+ // Some other validation outside basic Tab.
+
+ return errors;
+ }*/
+
+
+}
+
\ No newline at end of file
Index: lams_tool_eadventure/src/java/org/eucm/lams/tool/eadventure/web/action/ClearSessionAction.java
===================================================================
diff -u
--- lams_tool_eadventure/src/java/org/eucm/lams/tool/eadventure/web/action/ClearSessionAction.java (revision 0)
+++ lams_tool_eadventure/src/java/org/eucm/lams/tool/eadventure/web/action/ClearSessionAction.java (revision e7b84a8dda80b775d674d686a2564d40c7e3f871)
@@ -0,0 +1,50 @@
+/****************************************************************
+ * Copyright (C) 2005 LAMS Foundation (http://lamsfoundation.org)
+ * =============================================================
+ * License Information: http://lamsfoundation.org/licensing/lams/2.0/
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2.0
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
+ * USA
+ *
+ * http://www.gnu.org/licenses/gpl.txt
+ * ****************************************************************
+ */
+
+/* $Id$ */
+package org.eucm.lams.tool.eadventure.web.action;
+
+import javax.servlet.http.HttpSession;
+
+import org.lamsfoundation.lams.authoring.web.LamsAuthoringFinishAction;
+import org.lamsfoundation.lams.tool.ToolAccessMode;
+import org.eucm.lams.tool.eadventure.EadventureConstants;
+import org.lamsfoundation.lams.web.util.AttributeNames;
+
+/**
+ * This class give a chance to clear HttpSession when user save/close authoring page.
+ * @author Steve.Ni
+ *
+ * @version $Revision$
+ */
+public class ClearSessionAction extends LamsAuthoringFinishAction {
+
+ @Override
+ public void clearSession(String customiseSessionID, HttpSession session, ToolAccessMode mode) {
+ if(mode.isAuthor()){
+ session.removeAttribute(customiseSessionID);
+ }
+ }
+
+
+}
Index: lams_tool_eadventure/src/java/org/eucm/lams/tool/eadventure/web/action/LearningAction.java
===================================================================
diff -u
--- lams_tool_eadventure/src/java/org/eucm/lams/tool/eadventure/web/action/LearningAction.java (revision 0)
+++ lams_tool_eadventure/src/java/org/eucm/lams/tool/eadventure/web/action/LearningAction.java (revision e7b84a8dda80b775d674d686a2564d40c7e3f871)
@@ -0,0 +1,727 @@
+/****************************************************************
+ * Copyright (C) 2005 LAMS Foundation (http://lamsfoundation.org)
+ * =============================================================
+ * License Information: http://lamsfoundation.org/licensing/lams/2.0/
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2.0
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
+ * USA
+ *
+ * http://www.gnu.org/licenses/gpl.txt
+ * ****************************************************************
+ */
+
+/* $Id$ */
+package org.eucm.lams.tool.eadventure.web.action;
+
+import java.io.IOException;
+import java.sql.Timestamp;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.SortedSet;
+import java.util.TreeSet;
+
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.servlet.http.HttpSession;
+
+import org.apache.commons.lang.StringUtils;
+import org.apache.log4j.Logger;
+import org.apache.struts.action.Action;
+import org.apache.struts.action.ActionErrors;
+import org.apache.struts.action.ActionForm;
+import org.apache.struts.action.ActionForward;
+import org.apache.struts.action.ActionMapping;
+import org.apache.struts.action.ActionMessage;
+import org.apache.struts.action.ActionMessages;
+import org.lamsfoundation.lams.events.DeliveryMethodMail;
+import org.lamsfoundation.lams.notebook.model.NotebookEntry;
+import org.lamsfoundation.lams.notebook.service.CoreNotebookConstants;
+import org.lamsfoundation.lams.tool.ToolAccessMode;
+import org.eucm.lams.tool.eadventure.EadventureConstants;
+import org.eucm.lams.tool.eadventure.model.Eadventure;
+import org.eucm.lams.tool.eadventure.model.EadventureItemVisitLog;
+import org.eucm.lams.tool.eadventure.model.EadventureParam;
+import org.eucm.lams.tool.eadventure.model.EadventureSession;
+import org.eucm.lams.tool.eadventure.model.EadventureUser;
+import org.eucm.lams.tool.eadventure.model.EadventureVars;
+import org.eucm.lams.tool.eadventure.service.IEadventureService;
+import org.eucm.lams.tool.eadventure.service.EadventureApplicationException;
+import org.eucm.lams.tool.eadventure.service.UploadEadventureFileException;
+import org.eucm.lams.tool.eadventure.web.form.ReflectionForm;
+import org.lamsfoundation.lams.usermanagement.User;
+import org.lamsfoundation.lams.usermanagement.dto.UserDTO;
+import org.lamsfoundation.lams.util.FileUtil;
+import org.lamsfoundation.lams.util.FileValidatorUtil;
+import org.lamsfoundation.lams.util.WebUtil;
+import org.lamsfoundation.lams.web.session.SessionManager;
+import org.lamsfoundation.lams.web.util.AttributeNames;
+import org.lamsfoundation.lams.web.util.SessionMap;
+import org.springframework.web.context.WebApplicationContext;
+import org.springframework.web.context.support.WebApplicationContextUtils;
+
+/**
+ *
+ * @author Steve.Ni
+ *
+ * @version $Revision$
+ */
+public class LearningAction extends Action {
+
+ private static Logger log = Logger.getLogger(LearningAction.class);
+
+ @Override
+ public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request,
+ HttpServletResponse response) throws IOException, ServletException {
+
+ String param = mapping.getParameter();
+ // -----------------------Eadventure Learner function ---------------------------
+ if (param.equals("start")) {
+ return start(mapping, form, request, response);
+ }
+ if (param.equals("finish")) {
+ return finish(mapping, form, request, response);
+ }
+ if (param.equals("addfile")) {
+ //return addItem(mapping, form, request, response);
+ }
+ if (param.equals("addurl")) {
+ //return addItem(mapping, form, request, response);
+ }
+ if (param.equals("saveOrUpdateItem")) {
+ //return saveOrUpdateItem(mapping, form, request, response);
+ }
+
+ // ================ Reflection =======================
+ if (param.equals("newReflection")) {
+ return newReflection(mapping, form, request, response);
+ }
+ if (param.equals("submitReflection")) {
+ return submitReflection(mapping, form, request, response);
+ }
+
+ return mapping.findForward(EadventureConstants.ERROR);
+ }
+
+ /**
+ * Initial page for add eadventure item (single file or URL).
+ *
+ * @param mapping
+ * @param form
+ * @param request
+ * @param response
+ * @return
+ */
+ //TODO eliminar
+ /* private ActionForward addItem(ActionMapping mapping, ActionForm form, HttpServletRequest request,
+ HttpServletResponse response) {
+ EadventureItemForm itemForm = (EadventureItemForm) form;
+ itemForm.setMode(WebUtil.readStrParam(request, AttributeNames.ATTR_MODE));
+ itemForm.setSessionMapID(WebUtil.readStrParam(request, EadventureConstants.ATTR_SESSION_MAP_ID));
+ return mapping.findForward(EadventureConstants.SUCCESS);
+ }
+
+ /**
+ * Read eadventure data from database and put them into HttpSession. It will redirect to init.do directly after this
+ * method run successfully.
+ *
+ * This method will avoid read database again and lost un-saved resouce item lost when user "refresh page",
+ *
+ */
+ private ActionForward start(ActionMapping mapping, ActionForm form, HttpServletRequest request,
+ HttpServletResponse response) {
+
+ // initial Session Map
+ SessionMap sessionMap = new SessionMap();
+ request.getSession().setAttribute(sessionMap.getSessionID(), sessionMap);
+
+ // save toolContentID into HTTPSession
+ ToolAccessMode mode = WebUtil.readToolAccessModeParam(request, AttributeNames.PARAM_MODE, true);
+
+ Long sessionId = new Long(request.getParameter(EadventureConstants.PARAM_TOOL_SESSION_ID));
+
+ request.setAttribute(EadventureConstants.ATTR_SESSION_MAP_ID, sessionMap.getSessionID());
+ request.setAttribute(AttributeNames.ATTR_MODE, mode);
+ request.setAttribute(AttributeNames.PARAM_TOOL_SESSION_ID, sessionId);
+
+ // get back the eadventure and item list and display them on page
+ IEadventureService service = getEadventureService();
+ EadventureUser eadventureUser = null;
+ if (mode != null && mode.isTeacher()) {
+ // monitoring mode - user is specified in URL
+ // eadventureUser may be null if the user was force completed.
+ eadventureUser = getSpecifiedUser(service, sessionId, WebUtil.readIntParam(request,
+ AttributeNames.PARAM_USER_ID, false));
+ } else {
+ eadventureUser = getCurrentUser(service, sessionId);
+ //TODO mio!!!
+ if (eadventureUser==null){
+ log.debug("VAYA PUES, EADUSER ES NULL!!!!!!!!!!!!!!!!!!!!!!!!1");
+ }else{
+ sessionMap.put(EadventureConstants.ATTR_USER_ID,eadventureUser.getUserId().intValue());
+ sessionMap.put(EadventureConstants.ATTR_USER_FNAME,eadventureUser.getFirstName());
+ sessionMap.put(EadventureConstants.ATTR_USER_LNAME,eadventureUser.getLastName());
+ }
+
+ }
+
+
+ Eadventure eadventure;
+ eadventure = service.getEadventureBySessionId(sessionId);
+ if (eadventure==null)
+ log.error("EAD ===== NULL!!!!!!!!!!");
+
+ // check whehter finish lock is on/off
+ boolean lock = eadventure.getLockWhenFinished() && eadventureUser != null && eadventureUser.isSessionFinished();
+
+ // check whether there is only one eadventure item and run auto flag is true or not.
+ boolean runAuto = false;
+
+ //TODO modify!!
+ // only visible item can be run auto.
+ runAuto = true;
+ request.setAttribute(EadventureConstants.ATTR_RESOURCE_ITEM_UID, eadventure.getUid());
+
+
+
+ // get notebook entry
+ String entryText = new String();
+ boolean completed = false;
+ if (eadventureUser != null) {
+ NotebookEntry notebookEntry = service.getEntry(sessionId, CoreNotebookConstants.NOTEBOOK_TOOL,
+ EadventureConstants.TOOL_SIGNATURE, eadventureUser.getUserId().intValue());
+ // check if the item is completed previously
+ EadventureItemVisitLog eadLog = service.getEadventureItemLog(eadventure.getUid(), eadventureUser.getUserId());
+ if (eadLog!=null)
+ completed = eadLog.isComplete();
+ if (notebookEntry != null) {
+ entryText = notebookEntry.getEntry();
+ }
+ }
+
+ // check define complete
+ boolean isDefineComplete= false;
+ if (eadventure.isDefineComplete()){
+ List params = service.getEadventureParamByContentId(eadventure.getUid());
+
+ for (EadventureParam param:params){
+ if (param.getName().equals("completed")){
+ isDefineComplete=true;
+ break;
+ }
+ }
+ }
+
+
+ // basic information
+ sessionMap.put(EadventureConstants.ATTR_TITLE, eadventure.getTitle());
+ sessionMap.put(EadventureConstants.ATTR_RESOURCE_INSTRUCTION, eadventure.getInstructions());
+ sessionMap.put(EadventureConstants.ATTR_FINISH_LOCK, lock);
+ sessionMap.put(EadventureConstants.ATTR_LOCK_ON_FINISH, eadventure.getLockWhenFinished());
+ sessionMap.put(EadventureConstants.ATTR_USER_FINISHED, eadventureUser != null && eadventureUser.isSessionFinished());
+
+ //TODO Estamos pasando session ID por atributo y por session!!
+ sessionMap.put(AttributeNames.PARAM_TOOL_SESSION_ID, sessionId);
+ sessionMap.put(AttributeNames.PARAM_TOOL_CONTENT_ID, eadventure.getContentId());
+ sessionMap.put(AttributeNames.ATTR_MODE, mode);
+ // reflection information
+ sessionMap.put(EadventureConstants.ATTR_REFLECTION_ON, eadventure.isReflectOnActivity());
+ sessionMap.put(EadventureConstants.ATTR_REFLECTION_INSTRUCTION, eadventure.getReflectInstructions());
+ sessionMap.put(EadventureConstants.ATTR_REFLECTION_ENTRY, entryText);
+ sessionMap.put(EadventureConstants.ATTR_RUN_AUTO, new Boolean(runAuto));
+ sessionMap.put(EadventureConstants.PARAM_RESOURCE_ITEM_UID, eadventure.getUid());
+ sessionMap.put(EadventureConstants.ATTR_DEFINE_COMPLETED, isDefineComplete);
+ sessionMap.put(EadventureConstants.ATTR_COMPLETED, completed);
+ // add define later support
+ if (eadventure.isDefineLater()) {
+ return mapping.findForward("defineLater");
+ }
+
+ // set contentInUse flag to true!
+ eadventure.setContentInUse(true);
+ eadventure.setDefineLater(false);
+ service.saveOrUpdateEadventure(eadventure);
+
+ // add run offline support
+ if (eadventure.getRunOffline()) {
+ sessionMap.put(EadventureConstants.PARAM_RUN_OFFLINE, true);
+ return mapping.findForward("runOffline");
+ } else {
+ sessionMap.put(EadventureConstants.PARAM_RUN_OFFLINE, false);
+ }
+
+
+
+ // set complete flag for display purpose
+ //TODO getionar el complete
+ //if (eadventureUser != null) {
+ // service.retrieveComplete(eadventureItemList, eadventureUser);
+ //}
+ sessionMap.put(EadventureConstants.ATTR_EADVENTURE, eadventure);
+
+
+ return mapping.findForward(EadventureConstants.SUCCESS);
+ }
+
+ /**
+ * Finish learning session.
+ *
+ * @param mapping
+ * @param form
+ * @param request
+ * @param response
+ * @return
+ */
+ private ActionForward finish(ActionMapping mapping, ActionForm form, HttpServletRequest request,
+ HttpServletResponse response) {
+
+ // get back SessionMap
+ String sessionMapID = request.getParameter(EadventureConstants.ATTR_SESSION_MAP_ID);
+ //String toolContentID = request.getParameter(EadventureConstants.ATTR_TOOL_CONTENT_ID);
+ SessionMap sessionMap = (SessionMap) request.getSession().getAttribute(sessionMapID);
+ Long toolContentID = (Long) sessionMap.get(EadventureConstants.ATTR_TOOL_CONTENT_ID);
+ // get mode and ToolSessionID from sessionMAP
+ ToolAccessMode mode = (ToolAccessMode) sessionMap.get(AttributeNames.ATTR_MODE);
+ Long sessionId = (Long) sessionMap.get(AttributeNames.PARAM_TOOL_SESSION_ID);
+
+ // auto run mode, when use finish the only one eadventure item, mark it as complete then finish this activity as
+ // well.
+ String eadventureItemUid = request.getParameter(EadventureConstants.PARAM_RESOURCE_ITEM_UID);
+ IEadventureService service = getEadventureService();
+ Eadventure ead = service.getEadventureByContentId(toolContentID);
+
+ HttpSession ss = SessionManager.getSession();
+ UserDTO user = (UserDTO) ss.getAttribute(AttributeNames.USER);
+ Long userID = new Long(user.getUserID().longValue());
+
+
+ boolean completedFromEad=false;
+ if (ead.isDefineComplete()){
+ EadventureItemVisitLog log = service.getEadventureItemLog(ead.getUid(), userID);
+ EadventureVars var = service.getEadventureVars(log.getUid(), EadventureConstants.VAR_NAME_COMPLETED);
+ if (var!=null&&Boolean.parseBoolean(var.getValue())){
+ completedFromEad=true;
+ }
+ }
+
+ //if (eadventureItemUid != null ){
+
+
+ doComplete(request,ead.getUid());
+ ead.setComplete(true);
+
+ // NOTE:So far this flag is useless(31/08/2006).
+ // set flag, then finish page can know redir target is parent(AUTO_RUN) or self(normal)
+ // request.setAttribute(EadventureConstants.ATTR_RUN_AUTO, true);
+ //} else{
+ // request.setAttribute(EadventureConstants.ATTR_RUN_AUTO, false);
+ //}
+
+ if (!validateBeforeFinish(request, sessionMapID)) {
+ return mapping.getInputForward();
+ }
+
+
+ // get sessionId from HttpServletRequest
+ String nextActivityUrl = null;
+ try {
+ // HttpSession ss = SessionManager.getSession();
+ // UserDTO user = (UserDTO) ss.getAttribute(AttributeNames.USER);
+ // Long userID = new Long(user.getUserID().longValue());
+
+ nextActivityUrl = service.finishToolSession(sessionId, userID);
+ request.setAttribute(EadventureConstants.ATTR_NEXT_ACTIVITY_URL, nextActivityUrl);
+ } catch (EadventureApplicationException e) {
+ LearningAction.log.error("Failed get next activity url:" + e.getMessage());
+ }
+
+ return mapping.findForward(EadventureConstants.SUCCESS);
+ }
+
+ /**
+ * Save file or url eadventure item into database.
+ *
+ * @param mapping
+ * @param form
+ * @param request
+ * @param response
+ * @return
+ */
+ /* private ActionForward saveOrUpdateItem(ActionMapping mapping, ActionForm form, HttpServletRequest request,
+ HttpServletResponse response) {
+ // get back SessionMap
+ String sessionMapID = request.getParameter(EadventureConstants.ATTR_SESSION_MAP_ID);
+ SessionMap sessionMap = (SessionMap) request.getSession().getAttribute(sessionMapID);
+ request.setAttribute(EadventureConstants.ATTR_SESSION_MAP_ID, sessionMapID);
+
+ Long sessionId = (Long) sessionMap.get(EadventureConstants.ATTR_TOOL_SESSION_ID);
+
+ String mode = request.getParameter(AttributeNames.ATTR_MODE);
+ EadventureItemForm itemForm = (EadventureItemForm) form;
+ ActionErrors errors = validateEadventureItem(itemForm);
+
+ if (!errors.isEmpty()) {
+ this.addErrors(request, errors);
+ return findForward(itemForm.getItemType(), mapping);
+ }
+ short type = itemForm.getItemType();
+
+ // create a new EadventureItem
+ EadventureItem item = new EadventureItem();
+ IEadventureService service = getEadventureService();
+ EadventureUser eadventureUser = getCurrentUser(service, sessionId);
+ item.setType(type);
+ item.setTitle(itemForm.getTitle());
+ item.setDescription(itemForm.getDescription());
+ item.setCreateDate(new Timestamp(new Date().getTime()));
+ item.setCreateByAuthor(false);
+ item.setCreateBy(eadventureUser);
+
+ // special attribute for URL or FILE
+ if (type == EadventureConstants.RESOURCE_TYPE_FILE) {
+ try {
+ service.uploadEadventureItemFile(item, itemForm.getFile());
+ } catch (UploadEadventureFileException e) {
+ LearningAction.log.error("Failed upload Eadventure File " + e.toString());
+ return mapping.findForward(EadventureConstants.ERROR);
+ }
+ } else if (type == EadventureConstants.RESOURCE_TYPE_URL) {
+ item.setUrl(itemForm.getUrl());
+ item.setOpenUrlNewWindow(itemForm.isOpenUrlNewWindow());
+ }
+ // save and update session
+
+ EadventureSession resSession = service.getEadventureSessionBySessionId(sessionId);
+ if (resSession == null) {
+ LearningAction.log.error("Failed update EadventureSession by ID[" + sessionId + "]");
+ return mapping.findForward(EadventureConstants.ERROR);
+ }
+ Set items = resSession.getEadventureItems();
+ if (items == null) {
+ items = new HashSet();
+ resSession.setEadventureItems(items);
+ }
+ items.add(item);
+ service.saveOrUpdateEadventureSession(resSession);
+
+ // update session value
+ SortedSet eadventureItemList = getEadventureItemList(sessionMap);
+ eadventureItemList.add(item);
+
+ // URL or file upload
+ request.setAttribute(EadventureConstants.ATTR_ADD_RESOURCE_TYPE, new Short(type));
+ request.setAttribute(AttributeNames.ATTR_MODE, mode);
+
+ Eadventure eadventure = resSession.getEadventure();
+ if (eadventure.isNotifyTeachersOnAssigmentSumbit()) {
+ List monitoringUsers = service.getMonitorsByToolSessionId(sessionId);
+ if (monitoringUsers != null && !monitoringUsers.isEmpty()) {
+ Long[] monitoringUsersIds = new Long[monitoringUsers.size()];
+ for (int i = 0; i < monitoringUsersIds.length; i++) {
+ monitoringUsersIds[i] = monitoringUsers.get(i).getUserId().longValue();
+ }
+ String fullName = eadventureUser.getLastName() + " " + eadventureUser.getFirstName();
+ service.getEventNotificationService().sendMessage(monitoringUsersIds, DeliveryMethodMail.getInstance(),
+ service.getLocalisedMessage("event.assigment.submit.subject", null),
+ service.getLocalisedMessage("event.assigment.submit.body", new Object[] { fullName }));
+ }
+ }
+ return mapping.findForward(EadventureConstants.SUCCESS);
+ }
+
+ /**
+ * Display empty reflection form.
+ *
+ * @param mapping
+ * @param form
+ * @param request
+ * @param response
+ * @return
+ */
+ private ActionForward newReflection(ActionMapping mapping, ActionForm form, HttpServletRequest request,
+ HttpServletResponse response) {
+
+ // get session value
+ String sessionMapID = WebUtil.readStrParam(request, EadventureConstants.ATTR_SESSION_MAP_ID);
+ if (!validateBeforeFinish(request, sessionMapID)) {
+ return mapping.getInputForward();
+ }
+
+ ReflectionForm refForm = (ReflectionForm) form;
+ HttpSession ss = SessionManager.getSession();
+ UserDTO user = (UserDTO) ss.getAttribute(AttributeNames.USER);
+
+ refForm.setUserID(user.getUserID());
+ refForm.setSessionMapID(sessionMapID);
+
+ // get the existing reflection entry
+ IEadventureService submitFilesService = getEadventureService();
+
+ SessionMap map = (SessionMap) request.getSession().getAttribute(sessionMapID);
+ Long toolSessionID = (Long) map.get(AttributeNames.PARAM_TOOL_SESSION_ID);
+ NotebookEntry entry = submitFilesService.getEntry(toolSessionID, CoreNotebookConstants.NOTEBOOK_TOOL,
+ EadventureConstants.TOOL_SIGNATURE, user.getUserID());
+
+ if (entry != null) {
+ refForm.setEntryText(entry.getEntry());
+ }
+
+ return mapping.findForward(EadventureConstants.SUCCESS);
+ }
+
+ /**
+ * Submit reflection form input database.
+ *
+ * @param mapping
+ * @param form
+ * @param request
+ * @param response
+ * @return
+ */
+ private ActionForward submitReflection(ActionMapping mapping, ActionForm form, HttpServletRequest request,
+ HttpServletResponse response) {
+ ReflectionForm refForm = (ReflectionForm) form;
+ Integer userId = refForm.getUserID();
+
+ String sessionMapID = WebUtil.readStrParam(request, EadventureConstants.ATTR_SESSION_MAP_ID);
+ SessionMap sessionMap = (SessionMap) request.getSession().getAttribute(sessionMapID);
+ Long sessionId = (Long) sessionMap.get(AttributeNames.PARAM_TOOL_SESSION_ID);
+
+ IEadventureService service = getEadventureService();
+
+ // check for existing notebook entry
+ NotebookEntry entry = service.getEntry(sessionId, CoreNotebookConstants.NOTEBOOK_TOOL,
+ EadventureConstants.TOOL_SIGNATURE, userId);
+
+ if (entry == null) {
+ // create new entry
+ service.createNotebookEntry(sessionId, CoreNotebookConstants.NOTEBOOK_TOOL,
+ EadventureConstants.TOOL_SIGNATURE, userId, refForm.getEntryText());
+ } else {
+ // update existing entry
+ entry.setEntry(refForm.getEntryText());
+ entry.setLastModified(new Date());
+ service.updateEntry(entry);
+ }
+
+ return finish(mapping, form, request, response);
+ }
+
+ // *************************************************************************************
+ // Private method
+ // *************************************************************************************
+ //TODO valorar eliminarlo
+ private boolean validateBeforeFinish(HttpServletRequest request, String sessionMapID) {
+ SessionMap sessionMap = (SessionMap) request.getSession().getAttribute(sessionMapID);
+ Long sessionId = (Long) sessionMap.get(AttributeNames.PARAM_TOOL_SESSION_ID);
+
+ HttpSession ss = SessionManager.getSession();
+ UserDTO user = (UserDTO) ss.getAttribute(AttributeNames.USER);
+ Long userID = new Long(user.getUserID().longValue());
+
+ IEadventureService service = getEadventureService();
+ /*int miniViewFlag = service.checkMiniView(sessionId, userID);
+ // if current user view less than reqired view count number, then just return error message.
+ // if it is runOffline content, then need not check minimum view count
+ Boolean runOffline = (Boolean) sessionMap.get(EadventureConstants.PARAM_RUN_OFFLINE);
+ if (miniViewFlag > 0 && !runOffline) {
+ ActionErrors errors = new ActionErrors();
+ errors.add(ActionMessages.GLOBAL_MESSAGE, new ActionMessage("lable.learning.minimum.view.number.less",
+ miniViewFlag));
+ this.addErrors(request, errors);
+ return false;
+ }*/
+
+ return true;
+ }
+
+ private IEadventureService getEadventureService() {
+ WebApplicationContext wac = WebApplicationContextUtils.getRequiredWebApplicationContext(getServlet()
+ .getServletContext());
+ return (IEadventureService) wac.getBean(EadventureConstants.RESOURCE_SERVICE);
+ }
+
+ /**
+ * List save current eadventure items.
+ *
+ * @param request
+ * @return
+ */
+ /* private SortedSet getEadventureItemList(SessionMap sessionMap) {
+ SortedSet list = (SortedSet) sessionMap
+ .get(EadventureConstants.ATTR_RESOURCE_ITEM_LIST);
+ if (list == null) {
+ list = new TreeSet(new EadventureItemComparator());
+ sessionMap.put(EadventureConstants.ATTR_RESOURCE_ITEM_LIST, list);
+ }
+ return list;
+ }
+
+ /**
+ * Get java.util.List from HttpSession by given name.
+ *
+ * @param request
+ * @param name
+ * @return
+ */
+ private List getListFromSession(SessionMap sessionMap, String name) {
+ List list = (List) sessionMap.get(name);
+ if (list == null) {
+ list = new ArrayList();
+ sessionMap.put(name, list);
+ }
+ return list;
+ }
+
+ /**
+ * Return ActionForward according to eadventure item type.
+ *
+ * @param type
+ * @param mapping
+ * @return
+ */
+ private ActionForward findForward(short type, ActionMapping mapping) {
+ ActionForward forward;
+ switch (type) {
+ case EadventureConstants.RESOURCE_TYPE_URL:
+ forward = mapping.findForward("url");
+ break;
+ case EadventureConstants.RESOURCE_TYPE_FILE:
+ forward = mapping.findForward("file");
+ break;
+ case EadventureConstants.RESOURCE_TYPE_WEBSITE:
+ forward = mapping.findForward("website");
+ break;
+ case EadventureConstants.RESOURCE_TYPE_LEARNING_OBJECT:
+ forward = mapping.findForward("learningobject");
+ break;
+ default:
+ forward = null;
+ break;
+ }
+ return forward;
+ }
+
+ private EadventureUser getCurrentUser(IEadventureService service, Long sessionId) {
+ // try to get form system session
+ HttpSession ss = SessionManager.getSession();
+ // get back login user DTO
+ UserDTO user = (UserDTO) ss.getAttribute(AttributeNames.USER);
+ EadventureUser eadventureUser = service.getUserByIDAndSession(new Long(user.getUserID().intValue()), sessionId);
+ Eadventure ead = service.getEadventureBySessionId(sessionId);
+ // EadventureUser eadventureUser = service.getUserByIDAndContent(new Long(user.getUserID().intValue()), ead.getContentId());
+
+ if (eadventureUser == null) {
+ EadventureSession session = service.getEadventureSessionBySessionId(sessionId);
+ eadventureUser = new EadventureUser(user, session);
+ // eadventureUser.setEadventure(ead);
+ service.createUser(eadventureUser);
+ log.error("CREAMOS NUEVO USUARIO!!!! en getCurrentUSER");
+ } //TODO meter en un save or update de userDAO
+ //else
+
+ return eadventureUser;
+ }
+
+ private EadventureUser getSpecifiedUser(IEadventureService service, Long sessionId, Integer userId) {
+ EadventureUser eadventureUser = service.getUserByIDAndSession(new Long(userId.intValue()), sessionId);
+ if (eadventureUser == null) {
+ LearningAction.log
+ .error("Unable to find specified user for eadventure activity. Screens are likely to fail. SessionId="
+ + sessionId + " UserId=" + userId);
+ }
+ return eadventureUser;
+ }
+
+ /**
+ * @param itemForm
+ * @return
+ */
+ /*private ActionErrors validateEadventureItem(EadventureItemForm itemForm) {
+ ActionErrors errors = new ActionErrors();
+ if (StringUtils.isBlank(itemForm.getTitle())) {
+ errors.add(ActionMessages.GLOBAL_MESSAGE, new ActionMessage(EadventureConstants.ERROR_MSG_TITLE_BLANK));
+ }
+
+ if (itemForm.getItemType() == EadventureConstants.RESOURCE_TYPE_URL) {
+ if (StringUtils.isBlank(itemForm.getUrl())) {
+ errors.add(ActionMessages.GLOBAL_MESSAGE, new ActionMessage(EadventureConstants.ERROR_MSG_URL_BLANK));
+ // URL validation: Commom URL validate(1.3.0) work not very well: it can not support http://address:port
+ // format!!!
+ // UrlValidator validator = new UrlValidator();
+ // if(!validator.isValid(itemForm.getUrl()))
+ // errors.add(ActionMessages.GLOBAL_MESSAGE,new ActionMessage(EadventureConstants.ERROR_MSG_INVALID_URL));
+ }
+ }
+ // if(itemForm.getItemType() == EadventureConstants.RESOURCE_TYPE_WEBSITE
+ // ||itemForm.getItemType() == EadventureConstants.RESOURCE_TYPE_LEARNING_OBJECT){
+ // if(StringUtils.isBlank(itemForm.getDescription()))
+ // errors.add(ActionMessages.GLOBAL_MESSAGE,new ActionMessage(EadventureConstants.ERROR_MSG_DESC_BLANK));
+ // }
+ if (itemForm.getItemType() == EadventureConstants.RESOURCE_TYPE_WEBSITE
+ || itemForm.getItemType() == EadventureConstants.RESOURCE_TYPE_LEARNING_OBJECT
+ || itemForm.getItemType() == EadventureConstants.RESOURCE_TYPE_FILE) {
+
+ if (itemForm.getFile() != null && FileUtil.isExecutableFile(itemForm.getFile().getFileName())) {
+ ActionMessage msg = new ActionMessage("error.attachment.executable");
+ errors.add(ActionMessages.GLOBAL_MESSAGE, msg);
+ }
+
+ // validate item size
+ FileValidatorUtil.validateFileSize(itemForm.getFile(), false, errors);
+
+ // for edit validate: file already exist
+ if (!itemForm.isHasFile()
+ && (itemForm.getFile() == null || StringUtils.isEmpty(itemForm.getFile().getFileName()))) {
+ errors.add(ActionMessages.GLOBAL_MESSAGE, new ActionMessage(EadventureConstants.ERROR_MSG_FILE_BLANK));
+ }
+ }
+ return errors;
+ }*/
+
+ /**
+ * Set complete flag for given eadventure item.
+ *
+ * @param request
+ * @param sessionId
+ */
+ private void doComplete(HttpServletRequest request, Long eadUid) {
+ // get back sessionMap
+ String sessionMapID = request.getParameter(EadventureConstants.ATTR_SESSION_MAP_ID);
+ SessionMap sessionMap = (SessionMap) request.getSession().getAttribute(sessionMapID);
+
+ //Long eadventureItemUid = new Long(request.getParameter(EadventureConstants.PARAM_RESOURCE_ITEM_UID));
+ IEadventureService service = getEadventureService();
+ HttpSession ss = SessionManager.getSession();
+ // get back login user DTO
+ UserDTO user = (UserDTO) ss.getAttribute(AttributeNames.USER);
+
+ Long sessionId = (Long) sessionMap.get(EadventureConstants.ATTR_TOOL_SESSION_ID);
+ service.setItemComplete(eadUid, new Long(user.getUserID().intValue()), sessionId);
+
+ // set eadventure item complete tag
+ //TODO asignar complete
+ /*SortedSet eadventureItemList = getEadventureItemList(sessionMap);
+ for (EadventureItem item : eadventureItemList) {
+ if (item.getUid().equals(eadventureItemUid)) {
+ item.setComplete(true);
+ break;
+ }
+ }*/
+ }
+
+}
Index: lams_tool_eadventure/src/java/org/eucm/lams/tool/eadventure/web/action/MonitoringAction.java
===================================================================
diff -u
--- lams_tool_eadventure/src/java/org/eucm/lams/tool/eadventure/web/action/MonitoringAction.java (revision 0)
+++ lams_tool_eadventure/src/java/org/eucm/lams/tool/eadventure/web/action/MonitoringAction.java (revision e7b84a8dda80b775d674d686a2564d40c7e3f871)
@@ -0,0 +1,278 @@
+/****************************************************************
+ * Copyright (C) 2005 LAMS Foundation (http://lamsfoundation.org)
+ * =============================================================
+ * License Information: http://lamsfoundation.org/licensing/lams/2.0/
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2.0
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
+ * USA
+ *
+ * http://www.gnu.org/licenses/gpl.txt
+ * ****************************************************************
+ */
+
+/* $Id$ */
+package org.eucm.lams.tool.eadventure.web.action;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import org.apache.log4j.Logger;
+import org.apache.struts.action.Action;
+import org.apache.struts.action.ActionForm;
+import org.apache.struts.action.ActionForward;
+import org.apache.struts.action.ActionMapping;
+import org.lamsfoundation.lams.notebook.model.NotebookEntry;
+import org.lamsfoundation.lams.notebook.service.CoreNotebookConstants;
+import org.eucm.lams.tool.eadventure.EadventureConstants;
+import org.eucm.lams.tool.eadventure.dto.ReflectDTO;
+import org.eucm.lams.tool.eadventure.dto.Summary;
+import org.eucm.lams.tool.eadventure.model.Eadventure;
+import org.eucm.lams.tool.eadventure.model.EadventureItemVisitLog;
+import org.eucm.lams.tool.eadventure.model.EadventureSession;
+import org.eucm.lams.tool.eadventure.model.EadventureUser;
+import org.eucm.lams.tool.eadventure.model.EadventureVars;
+import org.eucm.lams.tool.eadventure.service.IEadventureService;
+import org.lamsfoundation.lams.tool.ToolOutput;
+import org.lamsfoundation.lams.util.WebUtil;
+import org.lamsfoundation.lams.web.util.AttributeNames;
+import org.lamsfoundation.lams.web.util.SessionMap;
+import org.springframework.web.context.WebApplicationContext;
+import org.springframework.web.context.support.WebApplicationContextUtils;
+
+public class MonitoringAction extends Action {
+ public static Logger log = Logger.getLogger(MonitoringAction.class);
+
+ @Override
+ public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request,
+ HttpServletResponse response) throws IOException, ServletException {
+ String param = mapping.getParameter();
+
+ request.setAttribute("initialTabId", WebUtil.readLongParam(request, AttributeNames.PARAM_CURRENT_TAB, true));
+
+ if (param.equals("summary")) {
+ return summary(mapping, form, request, response);
+ }
+
+ if (param.equals("listuser")) {
+ return listuser(mapping, form, request, response);
+ }
+ if (param.equals("showitem")) {
+ return showitem(mapping, form, request, response);
+ }
+ if (param.equals("hideitem")) {
+ return hideitem(mapping, form, request, response);
+ }
+ if (param.equals("viewReflection")) {
+ return viewReflection(mapping, form, request, response);
+ }
+ if (param.equals("showReport")) {
+ return showReport(mapping, form, request, response);
+ }
+
+ return mapping.findForward(EadventureConstants.ERROR);
+ }
+
+ private ActionForward showReport(ActionMapping mapping, ActionForm form, HttpServletRequest request,
+ HttpServletResponse response) {
+
+ // get back SessionMap
+ String sessionMapID = request.getParameter(EadventureConstants.ATTR_SESSION_MAP_ID);
+ //SessionMap sessionMap = (SessionMap) request.getSession().getAttribute(sessionMapID);
+ //request.setAttribute(EadventureConstants.ATTR_SESSION_MAP_ID, sessionMap.getSessionID());
+
+
+ IEadventureService service = getEadventureService();
+ Long sessionId = WebUtil.readLongParam(request, AttributeNames.PARAM_TOOL_SESSION_ID);
+ EadventureSession session = service.getEadventureSessionBySessionId(sessionId);
+ Eadventure ead = session.getEadventure();
+ Long uid = WebUtil.readLongParam(request, EadventureConstants.ATTR_USER_UID);
+ EadventureUser user = service.getUser(uid);
+
+ //TODO gestionar el report
+ //EadventureResult result = service.getLastEadventureResult(ead.getUid(), user.getUserId());
+ //
+ EadventureItemVisitLog log = service.getEadventureItemLog(ead.getUid(), user.getUserId());
+
+ EadventureVars var = service.getEadventureVars(log.getUid(), EadventureConstants.VAR_NAME_REPORT);
+ request.setAttribute("html", var.getValue());
+ return mapping.findForward(EadventureConstants.SUCCESS);
+ }
+
+ private ActionForward hideitem(ActionMapping mapping, ActionForm form, HttpServletRequest request,
+ HttpServletResponse response) {
+
+ Long itemUid = WebUtil.readLongParam(request, EadventureConstants.PARAM_RESOURCE_ITEM_UID);
+ IEadventureService service = getEadventureService();
+ service.setItemVisible(itemUid, false);
+
+ // get back SessionMap
+ String sessionMapID = request.getParameter(EadventureConstants.ATTR_SESSION_MAP_ID);
+ SessionMap sessionMap = (SessionMap) request.getSession().getAttribute(sessionMapID);
+ request.setAttribute(EadventureConstants.ATTR_SESSION_MAP_ID, sessionMap.getSessionID());
+
+ // update session value
+ List groupList = (List) sessionMap.get(EadventureConstants.ATTR_SUMMARY_LIST);
+ if (groupList != null) {
+ for (List group : groupList) {
+ for (Summary sum : group) {
+ if (itemUid.equals(sum.getItemUid())) {
+ sum.setItemHide(true);
+ break;
+ }
+ }
+ }
+ }
+
+ return mapping.findForward(EadventureConstants.SUCCESS);
+ }
+
+ private ActionForward showitem(ActionMapping mapping, ActionForm form, HttpServletRequest request,
+ HttpServletResponse response) {
+ Long itemUid = WebUtil.readLongParam(request, EadventureConstants.PARAM_RESOURCE_ITEM_UID);
+ IEadventureService service = getEadventureService();
+ service.setItemVisible(itemUid, true);
+
+ // get back SessionMap
+ String sessionMapID = request.getParameter(EadventureConstants.ATTR_SESSION_MAP_ID);
+ SessionMap sessionMap = (SessionMap) request.getSession().getAttribute(sessionMapID);
+ request.setAttribute(EadventureConstants.ATTR_SESSION_MAP_ID, sessionMap.getSessionID());
+
+ // update session value
+ List groupList = (List) sessionMap.get(EadventureConstants.ATTR_SUMMARY_LIST);
+ if (groupList != null) {
+ for (List group : groupList) {
+ for (Summary sum : group) {
+ if (itemUid.equals(sum.getItemUid())) {
+ sum.setItemHide(false);
+ break;
+ }
+ }
+ }
+ }
+ return mapping.findForward(EadventureConstants.SUCCESS);
+ }
+
+ private ActionForward summary(ActionMapping mapping, ActionForm form, HttpServletRequest request,
+ HttpServletResponse response) {
+ // initial Session Map
+ SessionMap sessionMap = new SessionMap();
+ request.getSession().setAttribute(sessionMap.getSessionID(), sessionMap);
+ request.setAttribute(EadventureConstants.ATTR_SESSION_MAP_ID, sessionMap.getSessionID());
+ // save contentFolderID into session
+ sessionMap.put(AttributeNames.PARAM_CONTENT_FOLDER_ID, WebUtil.readStrParam(request,
+ AttributeNames.PARAM_CONTENT_FOLDER_ID));
+
+ Long contentId = WebUtil.readLongParam(request, AttributeNames.PARAM_TOOL_CONTENT_ID);
+ IEadventureService service = getEadventureService();
+ List groupList = service.getSummary(contentId);
+
+ Eadventure eadventure = service.getEadventureByContentId(contentId);
+ eadventure.toDTO();
+
+ Map> relectList = service.getReflectList(contentId, false);
+
+ // cache into sessionMap
+ sessionMap.put(EadventureConstants.ATTR_SUMMARY_LIST, groupList);
+ sessionMap.put(EadventureConstants.PAGE_EDITABLE, eadventure.isContentInUse());
+ sessionMap.put(EadventureConstants.ATTR_EADVENTURE, eadventure);
+ sessionMap.put(EadventureConstants.ATTR_TOOL_CONTENT_ID, contentId);
+ sessionMap.put(EadventureConstants.ATTR_REFLECT_LIST, relectList);
+ return mapping.findForward(EadventureConstants.SUCCESS);
+ }
+
+ private ActionForward listuser(ActionMapping mapping, ActionForm form, HttpServletRequest request,
+ HttpServletResponse response) {
+ Long sessionId = WebUtil.readLongParam(request, AttributeNames.PARAM_TOOL_SESSION_ID);
+ Long itemUid = WebUtil.readLongParam(request, EadventureConstants.PARAM_RESOURCE_ITEM_UID);
+
+ // get user list by given item uid
+ IEadventureService service = getEadventureService();
+ List list = service.getUserListBySessionItem(sessionId, itemUid);
+
+ // set to request
+ request.setAttribute(EadventureConstants.ATTR_USER_LIST, list);
+ // check if there are associated report
+ EadventureSession session = service.getEadventureSessionBySessionId(sessionId);
+ Eadventure ead = session.getEadventure();
+ Long uid = WebUtil.readLongParam(request, EadventureConstants.ATTR_USER_UID);
+ EadventureUser user = service.getUser(uid);
+
+ //TODO gestionar el report
+ //EadventureResult result = service.getLastEadventureResult(ead.getUid(), user.getUserId());
+ EadventureItemVisitLog log = service.getEadventureItemLog(ead.getUid(), user.getUserId());
+
+ EadventureVars var = service.getEadventureVars(log.getUid(), EadventureConstants.VAR_NAME_REPORT);
+
+
+ int exist;
+ if (var!=null)
+ exist=0;
+ else
+ exist=1;
+ String sessionMapID = request.getParameter(EadventureConstants.ATTR_SESSION_MAP_ID);
+ SessionMap sessionMap = (SessionMap) request.getSession().getAttribute(sessionMapID);
+ request.setAttribute(EadventureConstants.ATTR_SESSION_MAP_ID, sessionMap.getSessionID());
+
+ sessionMap.put("existFile", exist);
+ //request.setAttribute("existFile",exist );
+ return mapping.findForward(EadventureConstants.SUCCESS);
+ }
+
+ private ActionForward viewReflection(ActionMapping mapping, ActionForm form, HttpServletRequest request,
+ HttpServletResponse response) {
+
+ Long uid = WebUtil.readLongParam(request, EadventureConstants.ATTR_USER_UID);
+ Long sessionID = WebUtil.readLongParam(request, AttributeNames.PARAM_TOOL_SESSION_ID);
+
+ IEadventureService service = getEadventureService();
+ EadventureUser user = service.getUser(uid);
+ NotebookEntry notebookEntry = service.getEntry(sessionID, CoreNotebookConstants.NOTEBOOK_TOOL,
+ EadventureConstants.TOOL_SIGNATURE, user.getUserId().intValue());
+
+ EadventureSession session = service.getEadventureSessionBySessionId(sessionID);
+
+ ReflectDTO refDTO = new ReflectDTO(user);
+ if (notebookEntry == null) {
+ refDTO.setFinishReflection(false);
+ refDTO.setReflect(null);
+ } else {
+ refDTO.setFinishReflection(true);
+ refDTO.setReflect(notebookEntry.getEntry());
+ }
+ refDTO.setReflectInstrctions(session.getEadventure().getReflectInstructions());
+
+ request.setAttribute("userDTO", refDTO);
+ return mapping.findForward("success");
+ }
+
+ // *************************************************************************************
+ // Private method
+ // *************************************************************************************
+ private IEadventureService getEadventureService() {
+ WebApplicationContext wac = WebApplicationContextUtils.getRequiredWebApplicationContext(getServlet()
+ .getServletContext());
+ return (IEadventureService) wac.getBean(EadventureConstants.RESOURCE_SERVICE);
+ }
+}
Index: lams_tool_eadventure/src/java/org/eucm/lams/tool/eadventure/web/action/ViewItemAction.java
===================================================================
diff -u
--- lams_tool_eadventure/src/java/org/eucm/lams/tool/eadventure/web/action/ViewItemAction.java (revision 0)
+++ lams_tool_eadventure/src/java/org/eucm/lams/tool/eadventure/web/action/ViewItemAction.java (revision e7b84a8dda80b775d674d686a2564d40c7e3f871)
@@ -0,0 +1,254 @@
+/****************************************************************
+ * Copyright (C) 2005 LAMS Foundation (http://lamsfoundation.org)
+ * =============================================================
+ * License Information: http://lamsfoundation.org/licensing/lams/2.0/
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2.0
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
+ * USA
+ *
+ * http://www.gnu.org/licenses/gpl.txt
+ * ****************************************************************
+ */
+
+/* $Id$ */
+package org.eucm.lams.tool.eadventure.web.action;
+
+import java.io.IOException;
+import java.io.UnsupportedEncodingException;
+import java.net.URLEncoder;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+import java.util.SortedSet;
+import java.util.TreeSet;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.servlet.http.HttpSession;
+
+import org.apache.commons.lang.math.NumberUtils;
+import org.apache.log4j.Logger;
+import org.apache.struts.action.Action;
+import org.apache.struts.action.ActionForm;
+import org.apache.struts.action.ActionForward;
+import org.apache.struts.action.ActionMapping;
+import org.lamsfoundation.lams.tool.ToolAccessMode;
+import org.eucm.lams.tool.eadventure.EadventureConstants;
+import org.eucm.lams.tool.eadventure.dto.InstructionNavDTO;
+import org.eucm.lams.tool.eadventure.model.Eadventure;
+import org.eucm.lams.tool.eadventure.service.IEadventureService;
+import org.eucm.lams.tool.eadventure.service.EadventureServiceProxy;
+import org.eucm.lams.tool.eadventure.util.EadventureWebUtils;
+import org.lamsfoundation.lams.usermanagement.dto.UserDTO;
+import org.lamsfoundation.lams.util.WebUtil;
+import org.lamsfoundation.lams.web.session.SessionManager;
+import org.lamsfoundation.lams.web.util.AttributeNames;
+import org.lamsfoundation.lams.web.util.SessionMap;
+import org.springframework.web.context.WebApplicationContext;
+import org.springframework.web.context.support.WebApplicationContextUtils;
+
+public class ViewItemAction extends Action {
+
+ private static final Logger log = Logger.getLogger(ViewItemAction.class);
+
+ private static IEadventureService eadventureService;
+
+ public ActionForward execute(ActionMapping mapping, ActionForm form,
+ HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {
+
+ String param = mapping.getParameter();
+ //-----------------------Display Learning Object function ---------------------------
+ if (param.equals("reviewItem")) {
+ return reviewItem(mapping, form, request, response);
+ }
+ //for preview top frame html page use:
+ if (param.equals("nextInstruction")) {
+ return nextInstruction(mapping, form, request, response);
+ }
+ //for preview top frame html page use:
+ if (param.equals("openUrlPopup")) {
+ //return openUrlPopup(mapping, form, request, response);
+ }
+
+ return mapping.findForward(EadventureConstants.ERROR);
+ }
+ /**
+ * Open url in popup window page.
+ * @param mapping
+ * @param form
+ * @param request
+ * @param response
+ * @return
+ */
+ //TODO ver si lo quitamos
+ /*private ActionForward openUrlPopup(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) {
+ String mode = request.getParameter(AttributeNames.ATTR_MODE);
+
+ if (eadventureService == null) {
+ eadventureService = EadventureServiceProxy.getEadventureService(getServlet().getServletContext());
+ }
+
+ String sessionMapID = WebUtil.readStrParam(request, EadventureConstants.ATTR_SESSION_MAP_ID);
+ SessionMap sessionMap = (SessionMap)request.getSession().getAttribute(sessionMapID);
+
+ EadventureItem item = getEadventureItem(request,sessionMap, mode);
+
+ request.setAttribute(EadventureConstants.PARAM_OPEN_URL_POPUP,item.getUrl());
+ request.setAttribute(EadventureConstants.PARAM_TITLE,item.getTitle());
+ return mapping.findForward(EadventureConstants.SUCCESS);
+ }*/
+ /**
+ * Return next instrucion to page. It need four input parameters, mode, itemIndex or itemUid, and insIdx.
+ * @param mapping
+ * @param form
+ * @param request
+ * @param response
+ * @return
+ */
+ private ActionForward nextInstruction(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) {
+ String mode = request.getParameter(AttributeNames.ATTR_MODE);
+
+ String sessionMapID = WebUtil.readStrParam(request, EadventureConstants.ATTR_SESSION_MAP_ID);
+ SessionMap sessionMap = (SessionMap)request.getSession().getAttribute(sessionMapID);
+
+ Eadventure ead = getEadventure(request, sessionMap, mode);
+ if(ead == null){
+ return mapping.findForward(EadventureConstants.ERROR);
+ }
+
+ String instruction = ead.getInstructions();
+ InstructionNavDTO navDto = new InstructionNavDTO();
+ navDto.setTitle(ead.getTitle());
+ navDto.setInstruction(instruction);
+
+ request.setAttribute(EadventureConstants.ATTR_TOOL_CONTENT_ID,ead.getContentId());
+ request.setAttribute(EadventureConstants.ATTR_SESSION_MAP_ID,sessionMapID);
+ request.setAttribute(EadventureConstants.ATTR_RESOURCE_INSTRUCTION,navDto);
+
+ return mapping.findForward(EadventureConstants.SUCCESS);
+ }
+
+ /**
+ * Display main frame to display instrcution and item content.
+ * @param mapping
+ * @param form
+ * @param request
+ * @param response
+ * @return
+ */
+ private ActionForward reviewItem(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) {
+ String mode = request.getParameter(AttributeNames.ATTR_MODE);
+
+ String sessionMapID = WebUtil.readStrParam(request, EadventureConstants.ATTR_SESSION_MAP_ID);
+ SessionMap sessionMap = (SessionMap)request.getSession().getAttribute(sessionMapID);
+
+ Eadventure ead = getEadventure(request,sessionMap, mode);
+
+ String idStr = request.getParameter(EadventureConstants.ATTR_TOOL_SESSION_ID);
+ Long sessionId = NumberUtils.createLong(idStr);
+ //mark this item access flag if it is learner
+ if(ToolAccessMode.LEARNER.toString().equals(mode)){
+ IEadventureService service = getEadventureService();
+ HttpSession ss = SessionManager.getSession();
+ //get back login user DTO
+ UserDTO user = (UserDTO) ss.getAttribute(AttributeNames.USER);
+ log.error("Vamos a setear el userID!!!!!!!!!!!!!!");
+ log.error("el usuario se llama "+ user.getFirstName());
+ log.error("su ID es "+ user.getUserID());
+
+ service.setItemAccess(ead.getUid(),new Long(user.getUserID().intValue()),sessionId);
+ }
+
+ if(ead == null){
+ return mapping.findForward(EadventureConstants.ERROR);
+ }
+ // TODO revisar
+ sessionMap.put(EadventureConstants.ATT_LEARNING_OBJECT,ead);
+
+
+ //params to eaGame
+ /*sessionMap.put(EadventureConstants.ATT_LEARNING_OBJECT,item);
+ sessionMap.put(EadventureConstants.ATT_LEARNING_OBJECT,item);
+ sessionMap.put(EadventureConstants.ATT_LEARNING_OBJECT,item);
+ sessionMap.put(EadventureConstants.ATT_LEARNING_OBJECT,item);*/
+
+ String reviewURL = "/pages/learningobj/mainframe.jsp?sessionMapID="+sessionMapID;
+ int itemIdx = NumberUtils.stringToInt(request.getParameter(EadventureConstants.PARAM_ITEM_INDEX));
+ request.setAttribute(EadventureConstants.ATTR_RESOURCE_REVIEW_URL,reviewURL);
+ //these attribute will be use to instruction navigator page
+ request.setAttribute(AttributeNames.ATTR_MODE,mode);
+ request.setAttribute(EadventureConstants.PARAM_ITEM_INDEX,itemIdx);
+ Long itemUid = NumberUtils.createLong(request.getParameter(EadventureConstants.PARAM_RESOURCE_ITEM_UID));
+ request.setAttribute(EadventureConstants.PARAM_RESOURCE_ITEM_UID,itemUid);
+ request.setAttribute(EadventureConstants.ATTR_TOOL_SESSION_ID,sessionId);
+ request.setAttribute(AttributeNames.PARAM_TOOL_CONTENT_ID,ead.getContentId());
+ request.setAttribute(EadventureConstants.ATTR_SESSION_MAP_ID,sessionMapID);
+
+ return mapping.findForward(EadventureConstants.SUCCESS);
+
+ }
+ //*************************************************************************************
+ // Private method
+ //*************************************************************************************
+ /**
+ * Return eadventure according to ToolAccessMode.
+ * @param request
+ * @param sessionMap
+ * @param mode
+ * @return
+ */
+ private Eadventure getEadventure(HttpServletRequest request, SessionMap sessionMap, String mode) {
+ Eadventure ead = null;
+ if(EadventureConstants.MODE_AUTHOR_SESSION.equals(mode)){
+ //int itemIdx = NumberUtils.stringToInt(request.getParameter(EadventureConstants.PARAM_ITEM_INDEX),0);
+ //authoring: does not save item yet, so only has ItemList from session and identity by Index
+ //List eadventureList = new ArrayList(getEadventureItemList(sessionMap));
+ ead = (Eadventure) sessionMap.get(EadventureConstants.ATTR_EADVENTURE);
+ }else{
+ //Long contentId = NumberUtils.createLong(request.getParameter(EadventureConstants.PARAM_TOOL_CONTENT_ID));
+ Long contentId = ((Long)sessionMap.get(EadventureConstants.PARAM_TOOL_CONTENT_ID));
+ //get back the eadventure and item list and display them on page
+ IEadventureService service = getEadventureService();
+ ead = service.getEadventureByContentId(contentId);
+
+ }
+ return ead;
+ }
+
+ private IEadventureService getEadventureService() {
+ WebApplicationContext wac = WebApplicationContextUtils.getRequiredWebApplicationContext(getServlet().getServletContext());
+ return (IEadventureService) wac.getBean(EadventureConstants.RESOURCE_SERVICE);
+ }
+
+ private static Pattern wikipediaPattern = Pattern.compile("wikipedia", Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE);
+
+
+ /**
+ * List save current eadventure items.
+ * @param request
+ * @return
+ */
+ /*private SortedSet getEadventureItemList(SessionMap sessionMap) {
+ SortedSet