コード例 #1
0
  private void buildMainScoreRulePerAnswer(ResponseCondition rule) {
    ensureFeedbackBasicOutcomeDeclaration();
    /*
    <responseCondition>
    	<responseIf>
    		<not>
    			<isNull>
    				<variable identifier="RESPONSE_1" />
    			</isNull>
    		</not>
    		<setOutcomeValue identifier="SCORE">
    			<sum>
    				<variable identifier="SCORE" />
    				<mapResponse identifier="RESPONSE_1" />
    			</sum>
    		</setOutcomeValue>
    		<setOutcomeValue identifier="FEEDBACKBASIC">
    			<baseValue baseType="identifier">
    				incorrect
    			</baseValue>
    		</setOutcomeValue>
    	</responseIf>
    </responseCondition>
     */
    ResponseIf responseIf = new ResponseIf(rule);
    rule.setResponseIf(responseIf);

    Not not = new Not(responseIf);
    responseIf.getExpressions().add(not);

    IsNull isNull = new IsNull(not);
    not.getExpressions().add(isNull);

    Variable responseVar = new Variable(isNull);
    ComplexReferenceIdentifier choiceResponseIdentifier =
        ComplexReferenceIdentifier.parseString(
            choiceInteraction.getResponseIdentifier().toString());
    responseVar.setIdentifier(choiceResponseIdentifier);
    isNull.getExpressions().add(responseVar);

    { // outcome score
      SetOutcomeValue scoreOutcome = new SetOutcomeValue(responseIf);
      scoreOutcome.setIdentifier(QTI21Constants.SCORE_IDENTIFIER);
      responseIf.getResponseRules().add(scoreOutcome);

      Sum sum = new Sum(scoreOutcome);
      scoreOutcome.getExpressions().add(sum);

      Variable scoreVar = new Variable(sum);
      scoreVar.setIdentifier(QTI21Constants.SCORE_CLX_IDENTIFIER);
      sum.getExpressions().add(scoreVar);

      MapResponse mapResponse = new MapResponse(sum);
      mapResponse.setIdentifier(choiceInteraction.getResponseIdentifier());
      sum.getExpressions().add(mapResponse);
    }

    { // outcome feedback
      SetOutcomeValue incorrectOutcomeValue = new SetOutcomeValue(responseIf);
      incorrectOutcomeValue.setIdentifier(QTI21Constants.FEEDBACKBASIC_IDENTIFIER);
      responseIf.getResponseRules().add(incorrectOutcomeValue);

      BaseValue incorrectValue = new BaseValue(incorrectOutcomeValue);
      incorrectValue.setBaseTypeAttrValue(BaseType.IDENTIFIER);
      incorrectValue.setSingleValue(QTI21Constants.INCORRECT_IDENTIFIER_VALUE);
      incorrectOutcomeValue.setExpression(incorrectValue);
    }
  }
コード例 #2
0
  private void buildMainScoreRuleAllCorrectAnswers(ResponseCondition rule) {
    ensureFeedbackBasicOutcomeDeclaration();
    /*
    	<responseIf>
    		<isNull>
    			<variable identifier="RESPONSE_1" />
    		</isNull>
    		<setOutcomeValue identifier="FEEDBACKBASIC">
    			<baseValue baseType="identifier">
    				empty
    			</baseValue>
    		</setOutcomeValue>
    	</responseIf>
    */

    // if no response
    ResponseIf responseIf = new ResponseIf(rule);
    rule.setResponseIf(responseIf);

    IsNull isNull = new IsNull(responseIf);
    responseIf.getExpressions().add(isNull);

    Variable variable = new Variable(isNull);
    variable.setIdentifier(ComplexReferenceIdentifier.parseString(responseIdentifier.toString()));
    isNull.getExpressions().add(variable);

    {
      SetOutcomeValue feedbackVar = new SetOutcomeValue(responseIf);
      feedbackVar.setIdentifier(QTI21Constants.FEEDBACKBASIC_IDENTIFIER);
      BaseValue feedbackVal = new BaseValue(feedbackVar);
      feedbackVal.setBaseTypeAttrValue(BaseType.IDENTIFIER);
      feedbackVal.setSingleValue(new IdentifierValue("empty"));
      feedbackVar.setExpression(feedbackVal);
      responseIf.getResponseRules().add(feedbackVar);
    }
    /*
    	<responseElseIf>
    		<match>
    			<variable identifier="RESPONSE_1" />
    			<correct identifier="RESPONSE_1" />
    		</match>
    		<setOutcomeValue identifier="SCORE">
    			<sum>
    				<variable identifier="SCORE" />
    				<variable identifier="MAXSCORE" />
    			</sum>
    		</setOutcomeValue>
    		<setOutcomeValue identifier="FEEDBACKBASIC">
    			<baseValue baseType="identifier">
    				correct
    			</baseValue>
    		</setOutcomeValue>
    	</responseElseIf>
    */

    // else if correct response
    ResponseElseIf responseElseIf = new ResponseElseIf(rule);
    rule.getResponseElseIfs().add(responseElseIf);

    // match
    {
      Match match = new Match(responseElseIf);
      responseElseIf.getExpressions().add(match);

      Variable responseVar = new Variable(match);
      responseVar.setIdentifier(
          ComplexReferenceIdentifier.parseString(responseIdentifier.toString()));
      match.getExpressions().add(responseVar);

      Correct correct = new Correct(match);
      correct.setIdentifier(ComplexReferenceIdentifier.parseString(responseIdentifier.toString()));
      match.getExpressions().add(correct);
    }

    // outcome score
    {
      SetOutcomeValue scoreOutcomeVar = new SetOutcomeValue(responseIf);
      scoreOutcomeVar.setIdentifier(QTI21Constants.SCORE_IDENTIFIER);
      responseElseIf.getResponseRules().add(scoreOutcomeVar);

      Sum sum = new Sum(scoreOutcomeVar);
      scoreOutcomeVar.getExpressions().add(sum);

      Variable scoreVar = new Variable(sum);
      scoreVar.setIdentifier(QTI21Constants.SCORE_CLX_IDENTIFIER);
      sum.getExpressions().add(scoreVar);

      Variable maxScoreVar = new Variable(sum);
      maxScoreVar.setIdentifier(QTI21Constants.MAXSCORE_CLX_IDENTIFIER);
      sum.getExpressions().add(maxScoreVar);
    }

    // outcome feedback
    {
      SetOutcomeValue correctFeedbackVar = new SetOutcomeValue(responseIf);
      correctFeedbackVar.setIdentifier(QTI21Constants.FEEDBACKBASIC_IDENTIFIER);
      BaseValue correctFeedbackVal = new BaseValue(correctFeedbackVar);
      correctFeedbackVal.setBaseTypeAttrValue(BaseType.IDENTIFIER);
      correctFeedbackVal.setSingleValue(QTI21Constants.CORRECT_IDENTIFIER_VALUE);
      correctFeedbackVar.setExpression(correctFeedbackVal);
      responseElseIf.getResponseRules().add(correctFeedbackVar);
    }

    /*
    	<responseElse>
    		<setOutcomeValue identifier="FEEDBACKBASIC">
    			<baseValue baseType="identifier">
    				incorrect
    			</baseValue>
    		</setOutcomeValue>
    	</responseElse>
    </responseCondition>
    */

    ResponseElse responseElse = new ResponseElse(rule);
    rule.setResponseElse(responseElse);
    { // feedback incorrect
      SetOutcomeValue incorrectFeedbackVar = new SetOutcomeValue(responseIf);
      incorrectFeedbackVar.setIdentifier(QTI21Constants.FEEDBACKBASIC_IDENTIFIER);
      BaseValue incorrectFeedbackVal = new BaseValue(incorrectFeedbackVar);
      incorrectFeedbackVal.setBaseTypeAttrValue(BaseType.IDENTIFIER);
      incorrectFeedbackVal.setSingleValue(QTI21Constants.INCORRECT_IDENTIFIER_VALUE);
      incorrectFeedbackVar.setExpression(incorrectFeedbackVal);
      responseElse.getResponseRules().add(incorrectFeedbackVar);
    }
  }