Coverage Report - org.kuali.student.lum.program.server.MajorDisciplineRpcServlet
 
Classes in this File Line Coverage Branch Coverage Complexity
MajorDisciplineRpcServlet
0%
0/78
0%
0/27
2.5
MajorDisciplineRpcServlet$1
0%
0/1
N/A
2.5
 
 1  
 package org.kuali.student.lum.program.server;
 2  
 
 3  
 import java.util.ArrayList;
 4  
 import java.util.HashMap;
 5  
 import java.util.List;
 6  
 import java.util.Map;
 7  
 
 8  
 import org.apache.log4j.Logger;
 9  
 import org.kuali.student.common.assembly.data.Data;
 10  
 import org.kuali.student.common.dto.RichTextInfo;
 11  
 import org.kuali.student.common.dto.StatusInfo;
 12  
 import org.kuali.student.common.ui.client.service.DataSaveResult;
 13  
 import org.kuali.student.common.ui.server.gwt.DataGwtServlet;
 14  
 import org.kuali.student.common.versionmanagement.dto.VersionDisplayInfo;
 15  
 import org.kuali.student.core.statement.dto.ReqComponentInfo;
 16  
 import org.kuali.student.core.statement.dto.StatementTreeViewInfo;
 17  
 import org.kuali.student.core.statement.service.StatementService;
 18  
 import org.kuali.student.core.statement.ui.client.widgets.rules.ReqComponentInfoUi;
 19  
 import org.kuali.student.core.statement.ui.client.widgets.rules.RulesUtil;
 20  
 import org.kuali.student.lum.common.server.StatementUtil;
 21  
 import org.kuali.student.lum.program.client.ProgramConstants;
 22  
 import org.kuali.student.lum.program.client.requirements.ProgramRequirementsDataModel;
 23  
 import org.kuali.student.lum.program.client.requirements.ProgramRequirementsSummaryView;
 24  
 import org.kuali.student.lum.program.client.rpc.MajorDisciplineRpcService;
 25  
 import org.kuali.student.lum.program.dto.ProgramRequirementInfo;
 26  
 import org.kuali.student.lum.program.service.ProgramService;
 27  
 import org.kuali.student.lum.program.service.ProgramServiceConstants;
 28  
 
 29  0
 public class MajorDisciplineRpcServlet extends DataGwtServlet implements MajorDisciplineRpcService {
 30  
 
 31  
     public static final String PREVIOUS_VERSION_INFO = "previousVersionInfo";
 32  
     
 33  0
     final Logger LOG = Logger.getLogger(MajorDisciplineRpcServlet.class);
 34  
     
 35  
     private static final long serialVersionUID = 1L;
 36  
 
 37  
     private ProgramService programService;
 38  
     private StatementService statementService;
 39  
     protected StateChangeService stateChangeService;
 40  
  
 41  
     /**
 42  
      * 
 43  
      * This method will update the state of a major discipline. 
 44  
      * 
 45  
      * @see org.kuali.student.lum.program.client.rpc.MajorDisciplineRpcService#updateStatus(org.kuali.student.common.assembly.data.Data, java.lang.String)
 46  
      */
 47  
         public DataSaveResult updateState(Data data, String state ) throws Exception {
 48  
              try {
 49  
                 // Pull program ID from model
 50  0
                 String programId = data.get(ProgramConstants.ID);
 51  
                 
 52  
                 // Pull endEntryTerm and endEnrollTerm from model
 53  
                 // These are set using drop downs when a program is activated
 54  0
                   Data previousVersionInfo = data.query(PREVIOUS_VERSION_INFO);
 55  0
                   String endEntryTerm = null;
 56  0
                   String endEnrollTerm = null;
 57  0
                  if (previousVersionInfo != null) {
 58  0
                    endEntryTerm = previousVersionInfo.get(ProgramConstants.END_PROGRAM_ENTRY_TERM); 
 59  0
               endEnrollTerm = previousVersionInfo.get(ProgramConstants.END_PROGRAM_ENROLL_TERM);
 60  0
               stateChangeService.changeState(endEntryTerm, endEnrollTerm,  programId, state);
 61  
                  }
 62  
                  else{
 63  
                     // previousVersionInfo is null if this is the first version 
 64  0
                     stateChangeService.changeState( programId, state);  
 65  
                  }
 66  
           
 67  
     
 68  
                 // Return updates to view
 69  0
                     DataSaveResult result = new DataSaveResult();
 70  0
                     result.setValue(data);
 71  0
                     return result;
 72  0
              } catch(Exception e){
 73  0
                      LOG.error("Error Updating Major Dicipline State", e);                 
 74  0
                  throw e;
 75  
              }
 76  
                  
 77  
         }
 78  
     public List<ProgramRequirementInfo> getProgramRequirements(List<String> programRequirementIds) throws Exception {
 79  
 
 80  0
         List<ProgramRequirementInfo> programReqInfos = new ArrayList<ProgramRequirementInfo>();
 81  
 
 82  0
         for (String programReqId : programRequirementIds) {
 83  0
             ProgramRequirementInfo rule = programService.getProgramRequirement(programReqId, null, null);
 84  0
             setProgReqNL(rule);
 85  0
             programReqInfos.add(rule);
 86  0
         }
 87  
 
 88  0
         return programReqInfos;
 89  
     }
 90  
 
 91  
     public Map<Integer, ProgramRequirementInfo> storeProgramRequirements(Map<Integer, ProgramRequirementsDataModel.requirementState> states,
 92  
                                                                         Map<Integer, ProgramRequirementInfo> progReqs) throws Exception {
 93  0
         Map<Integer, ProgramRequirementInfo> storedRules = new HashMap<Integer, ProgramRequirementInfo>();
 94  
 
 95  0
         for (Integer key : progReqs.keySet()) {
 96  0
             ProgramRequirementInfo rule = progReqs.get(key);
 97  0
             switch (states.get(key)) {
 98  
                 case STORED:
 99  
                     //rule was not changed so continue
 100  0
                     storedRules.put(key, null);
 101  0
                     break;
 102  
                 case ADDED:
 103  0
                     storedRules.put(key, createProgramRequirement(rule));
 104  0
                     break;
 105  
                 case EDITED:
 106  0
                     storedRules.put(key, updateProgramRequirement(rule));
 107  0
                     break;
 108  
                 case DELETED:
 109  0
                     storedRules.put(key, null);
 110  0
                     deleteProgramRequirement(rule.getId());
 111  0
                     break;
 112  
                 default:
 113  
                     break;
 114  
             }
 115  0
         }
 116  0
         return storedRules;
 117  
     }
 118  
 
 119  
  
 120  
     public ProgramRequirementInfo createProgramRequirement(ProgramRequirementInfo programRequirementInfo) throws Exception {
 121  
 
 122  
         // If this requirement is using a temporary statement ID set the state to null
 123  0
         if (programRequirementInfo.getId().indexOf(ProgramRequirementsSummaryView.NEW_PROG_REQ_ID) >= 0) {
 124  0
             programRequirementInfo.setId(null);
 125  
         }
 126  
         
 127  
         // Strip the temporary statement IDs and allow permanent IDs to be created when written to the web service
 128  0
         StatementUtil.stripStatementIds(programRequirementInfo.getStatement());
 129  
         
 130  
         // Update the state of the statement tree to match the state of the requirement
 131  
         // Note: the requirement state already matches the program state (e.g. Draft, Approved, etc)
 132  0
         StatementUtil.updateStatementTreeViewInfoState(programRequirementInfo.getState(), programRequirementInfo.getStatement());
 133  
        
 134  
         // Call the web service to create the requirement and statement tree in the database
 135  0
         ProgramRequirementInfo rule = programService.createProgramRequirement(programRequirementInfo);
 136  
         
 137  
         // Translate the requirement into its natural language equivalent
 138  0
         setProgReqNL(rule);
 139  
 
 140  0
         return rule;
 141  
     }
 142  
 
 143  
     public StatusInfo deleteProgramRequirement(String programRequirementId) throws Exception {
 144  0
         return programService.deleteProgramRequirement(programRequirementId);
 145  
     }
 146  
 
 147  
     public ProgramRequirementInfo updateProgramRequirement(ProgramRequirementInfo programRequirementInfo) throws Exception {
 148  
         
 149  
         // Strip the temporary statement IDs and allow permanent IDs to be created when written to the web service
 150  0
         StatementUtil.stripStatementIds(programRequirementInfo.getStatement());
 151  
 
 152  
         // Update the state of the statement tree to match the state of the requirement
 153  
         // Note: the requirement state already matches the program state (e.g. Draft, Approved, etc)
 154  0
         StatementUtil.updateStatementTreeViewInfoState(programRequirementInfo.getState(), programRequirementInfo.getStatement());
 155  
         
 156  
         //TODO temporary fix - see KSLUM 1421
 157  0
         if (programRequirementInfo.getDescr() == null) {
 158  0
             programRequirementInfo.setDescr(new RichTextInfo());    
 159  
         }
 160  
 
 161  0
         ProgramRequirementInfo rule = programService.updateProgramRequirement(programRequirementInfo);
 162  0
         setProgReqNL(rule);
 163  0
         return rule;
 164  
     }
 165  
 
 166  
     private void setProgReqNL(ProgramRequirementInfo programRequirementInfo) throws Exception {
 167  0
         setReqCompNL(programRequirementInfo.getStatement());
 168  0
     }
 169  
 
 170  
     private void setReqCompNL(StatementTreeViewInfo tree) throws Exception {
 171  0
         List<StatementTreeViewInfo> statements = tree.getStatements();
 172  0
         List<ReqComponentInfo> reqComponentInfos = tree.getReqComponents();
 173  
 
 174  0
          if ((statements != null) && (statements.size() > 0)) {
 175  
             // retrieve all statements
 176  0
             for (StatementTreeViewInfo statement : statements) {
 177  0
                 setReqCompNL(statement); // inside set the children of this statementTreeViewInfo
 178  
             }
 179  0
         } else if ((reqComponentInfos != null) && (reqComponentInfos.size() > 0)) {
 180  
             // retrieve all req. component LEAFS
 181  0
                 for (int i = 0; i < reqComponentInfos.size(); i++) {
 182  0
                         ReqComponentInfoUi reqUi = RulesUtil.clone(reqComponentInfos.get(i));
 183  0
                         reqUi.setNaturalLanguageTranslation(statementService.translateReqComponentToNL(reqUi, "KUALI.RULE", "en"));
 184  0
                         reqUi.setPreviewNaturalLanguageTranslation(statementService.translateReqComponentToNL(reqUi, "KUALI.RULE.PREVIEW", "en"));
 185  0
                         reqComponentInfos.set(i, reqUi);
 186  
                 }
 187  
         }
 188  0
     }
 189  
     
 190  
     @Override
 191  
         public Boolean isLatestVersion(String versionIndId, Long versionSequenceNumber) throws Exception {
 192  0
             VersionDisplayInfo versionDisplayInfo = programService.getLatestVersion(ProgramServiceConstants.PROGRAM_NAMESPACE_MAJOR_DISCIPLINE_URI, versionIndId);
 193  0
             Long latestSequenceNumber = versionDisplayInfo.getSequenceNumber();
 194  0
             boolean isLatest = latestSequenceNumber.equals(versionSequenceNumber); 
 195  
             
 196  0
             return isLatest;
 197  
         }
 198  
 
 199  
         public void setProgramService(ProgramService programService) {
 200  0
         this.programService = programService;
 201  0
     }
 202  
 
 203  
     public void setStatementService(StatementService statementService) {
 204  0
         this.statementService = statementService;
 205  0
     }
 206  
 
 207  
     public void setStateChangeService(StateChangeService stateChangeService) {
 208  0
         this.stateChangeService = stateChangeService;
 209  0
     }
 210  
     
 211  
 }