Examples with SetOutcomeValue uk.ac.ed.ph.jqtiplus.node.item.response.processing.SetOutcomeValue used on opensource projects

Example 51 with SetOutcomeValue

use of uk.ac.ed.ph.jqtiplus.node.item.response.processing.SetOutcomeValue in project openolat by klemens.

the class AssessmentItemFactory method createModalFeedbackResponseConditionByScore.

/**
 * This generate a response rule which compare the max score and the score
 * to set the feedback as "correct".
 *
 *	<responseCondition>
 *		<responseIf>
 *			<and>
 *				<not>
 *					<match>
 *						<variable identifier="FEEDBACKBASIC" />
 *						<baseValue baseType="identifier">empty</baseValue>
 *					</match>
 *				</not>
 *				<equal toleranceMode="exact">
 *					<variable identifier="SCORE" />
 *					<variable identifier="MAXSCORE" />
 *				</equal>
 *			</and>
 *			<setOutcomeValue identifier="FEEDBACKBASIC">
 *				<baseValue baseType="identifier">correct</baseValue>
 *			</setOutcomeValue>
 *		</responseIf>
 *	</responseCondition>
 */
public static ResponseCondition createModalFeedbackResponseConditionByScore(ResponseProcessing responseProcessing) {
    ResponseCondition responseCondition = new ResponseCondition(responseProcessing);
    ResponseIf responseIf = new ResponseIf(responseCondition);
    responseCondition.setResponseIf(responseIf);
    And and = new And(responseIf);
    responseIf.getExpressions().add(and);
    Not not = new Not(and);
    and.getExpressions().add(not);
    Match match = new Match(not);
    not.getExpressions().add(match);
    Variable feedbackbasicVar = new Variable(match);
    feedbackbasicVar.setIdentifier(QTI21Constants.FEEDBACKBASIC_CLX_IDENTIFIER);
    match.getExpressions().add(feedbackbasicVar);
    BaseValue emptyValue = new BaseValue(match);
    emptyValue.setBaseTypeAttrValue(BaseType.IDENTIFIER);
    emptyValue.setSingleValue(QTI21Constants.EMPTY_IDENTIFIER_VALUE);
    match.getExpressions().add(emptyValue);
    // SCORE >= MAXSCORE ( > is for security and special case where the max score is smalle than the sum of correct answers)
    Gte greaterOrEqual = new Gte(and);
    and.getExpressions().add(greaterOrEqual);
    Variable scoreVar = new Variable(greaterOrEqual);
    scoreVar.setIdentifier(QTI21Constants.SCORE_CLX_IDENTIFIER);
    greaterOrEqual.getExpressions().add(scoreVar);
    Variable maxScoreVar = new Variable(greaterOrEqual);
    maxScoreVar.setIdentifier(QTI21Constants.MAXSCORE_CLX_IDENTIFIER);
    greaterOrEqual.getExpressions().add(maxScoreVar);
    // outcome value
    SetOutcomeValue correctOutcomeValue = new SetOutcomeValue(responseIf);
    correctOutcomeValue.setIdentifier(QTI21Constants.FEEDBACKBASIC_IDENTIFIER);
    responseIf.getResponseRules().add(correctOutcomeValue);
    BaseValue correctValue = new BaseValue(correctOutcomeValue);
    correctValue.setBaseTypeAttrValue(BaseType.IDENTIFIER);
    correctValue.setSingleValue(QTI21Constants.CORRECT_IDENTIFIER_VALUE);
    correctOutcomeValue.setExpression(correctValue);
    return responseCondition;
}

Example 52 with SetOutcomeValue

use of uk.ac.ed.ph.jqtiplus.node.item.response.processing.SetOutcomeValue in project openolat by klemens.

the class AssessmentItemFactory method createCorrectSolutionModalFeedbackBasicRule.

/**
 * Generate the special case for "correct solution" feedback which is almost the same as
 * incorrect feedback.
 *
 * @param responseProcessing
 * @param feedbackIdentifier
 * @return
 */
public static ResponseCondition createCorrectSolutionModalFeedbackBasicRule(ResponseProcessing responseProcessing, Identifier correctSolutionFeedbackIdentifier, Identifier incorrectFeedbackIdentifier, boolean hint) {
    ResponseCondition rule = new ResponseCondition(responseProcessing);
    /*
		<responseIf>
			<and>
				<match>
					<baseValue baseType="identifier">incorrect</baseValue>
					<variable identifier="FEEDBACKBASIC" />
				</match>
			</and>
			<setOutcomeValue identifier="FEEDBACKMODAL">
				<multiple>
					<variable identifier="FEEDBACKMODAL" />
					<baseValue baseType="identifier">Feedback261171147</baseValue>
				</multiple>
			</setOutcomeValue>
			<setOutcomeValue identifier="SOLUTIONMODAL">
				<baseValue baseType="identifier">Feedback261171147</baseValue>
			</setOutcomeValue>
		</responseIf>
		*/
    ResponseIf responseIf = new ResponseIf(rule);
    rule.setResponseIf(responseIf);
    {
        // rule
        And and = new And(responseIf);
        responseIf.getExpressions().add(and);
        Match match = new Match(and);
        and.getExpressions().add(match);
        BaseValue feedbackVal = new BaseValue(match);
        feedbackVal.setBaseTypeAttrValue(BaseType.IDENTIFIER);
        feedbackVal.setSingleValue(new IdentifierValue(QTI21Constants.INCORRECT));
        match.getExpressions().add(feedbackVal);
        Variable variable = new Variable(match);
        variable.setIdentifier(ComplexReferenceIdentifier.parseString(QTI21Constants.FEEDBACKBASIC));
        match.getExpressions().add(variable);
        // not match the HINT
        if (hint) {
            IsNull isNull = new IsNull(and);
            and.getExpressions().add(isNull);
            Variable hintVar = new Variable(isNull);
            hintVar.setIdentifier(QTI21Constants.HINT_FEEDBACKMODAL_CLX_IDENTIFIER);
            isNull.getExpressions().add(hintVar);
        }
    }
    if (incorrectFeedbackIdentifier != null) {
        // outcome incorrect
        SetOutcomeValue feedbackVar = new SetOutcomeValue(responseIf);
        feedbackVar.setIdentifier(QTI21Constants.FEEDBACKMODAL_IDENTIFIER);
        Multiple multiple = new Multiple(feedbackVar);
        feedbackVar.setExpression(multiple);
        Variable variable = new Variable(multiple);
        variable.setIdentifier(ComplexReferenceIdentifier.parseString(QTI21Constants.FEEDBACKMODAL));
        multiple.getExpressions().add(variable);
        BaseValue feedbackVal = new BaseValue(feedbackVar);
        feedbackVal.setBaseTypeAttrValue(BaseType.IDENTIFIER);
        feedbackVal.setSingleValue(new IdentifierValue(incorrectFeedbackIdentifier));
        multiple.getExpressions().add(feedbackVal);
        responseIf.getResponseRules().add(feedbackVar);
    }
    if (correctSolutionFeedbackIdentifier != null) {
        // outcome correct solution
        SetOutcomeValue feedbackVar = new SetOutcomeValue(responseIf);
        feedbackVar.setIdentifier(QTI21Constants.CORRECT_SOLUTION_IDENTIFIER);
        BaseValue feedbackVal = new BaseValue(feedbackVar);
        feedbackVal.setBaseTypeAttrValue(BaseType.IDENTIFIER);
        feedbackVal.setSingleValue(new IdentifierValue(correctSolutionFeedbackIdentifier));
        feedbackVar.getExpressions().add(feedbackVal);
        responseIf.getResponseRules().add(feedbackVar);
    }
    return rule;
}

Example 53 with SetOutcomeValue

use of uk.ac.ed.ph.jqtiplus.node.item.response.processing.SetOutcomeValue in project openolat by klemens.

the class AssessmentItemFactory method createMaxScoreBoundLimitRule.

/**
 * Rule which ensure that the final score is not above the max. score value.
 */
public static ResponseRule createMaxScoreBoundLimitRule(ResponseProcessing responseProcessing) {
    /*
		<responseCondition>
			<responseIf>
				<gt>
					<variable identifier="SCORE" /><variable identifier="MAXSCORE" />
				</gt>
				<setOutcomeValue identifier="SCORE">
					<variable identifier="MAXSCORE" />
				</setOutcomeValue>
			</responseIf>
		</responseCondition>
		*/
    ResponseCondition rule = new ResponseCondition(responseProcessing);
    ResponseIf responseIf = new ResponseIf(rule);
    rule.setResponseIf(responseIf);
    Gt gt = new Gt(responseIf);
    responseIf.setExpression(gt);
    Variable scoreVar = new Variable(gt);
    scoreVar.setIdentifier(SCORE_CLX_IDENTIFIER);
    gt.getExpressions().add(scoreVar);
    Variable maxScoreVar = new Variable(gt);
    maxScoreVar.setIdentifier(MAXSCORE_CLX_IDENTIFIER);
    gt.getExpressions().add(maxScoreVar);
    SetOutcomeValue setOutcomeValue = new SetOutcomeValue(responseIf);
    setOutcomeValue.setIdentifier(SCORE_IDENTIFIER);
    Variable maxScoreOutcomeVar = new Variable(setOutcomeValue);
    maxScoreOutcomeVar.setIdentifier(MAXSCORE_CLX_IDENTIFIER);
    setOutcomeValue.setExpression(maxScoreOutcomeVar);
    responseIf.getResponseRules().add(setOutcomeValue);
    return rule;
}

Example 54 with SetOutcomeValue

use of uk.ac.ed.ph.jqtiplus.node.item.response.processing.SetOutcomeValue in project openolat by klemens.

the class AssessmentItemFactory method appendSetOutcomeScoreMaxScore.

/*
	<setOutcomeValue identifier="SCORE">
	    <sum>
	      <variable identifier="SCORE"/>
	      <variable identifier="MAXSCORE"/>
	    </sum>
	  </setOutcomeValue>
	*/
public static void appendSetOutcomeScoreMaxScore(ResponseConditionChild responseCondition) {
    SetOutcomeValue scoreOutcomeValue = new SetOutcomeValue(responseCondition);
    scoreOutcomeValue.setIdentifier(QTI21Constants.SCORE_IDENTIFIER);
    responseCondition.getResponseRules().add(scoreOutcomeValue);
    Sum sum = new Sum(scoreOutcomeValue);
    scoreOutcomeValue.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);
}

Example 55 with SetOutcomeValue

use of uk.ac.ed.ph.jqtiplus.node.item.response.processing.SetOutcomeValue in project openolat by klemens.

the class AssessmentItemFactory method matchAdditionalFeedback.

/**
 * the additional feedback have only responseIf
 *
 * @param item
 * @param feedback
 * @return
 */
public static boolean matchAdditionalFeedback(AssessmentItem item, ModalFeedback feedback) {
    List<ResponseRule> responseRules = item.getResponseProcessing().getResponseRules();
    for (ResponseRule responseRule : responseRules) {
        if (responseRule instanceof ResponseCondition) {
            ResponseCondition responseCondition = (ResponseCondition) responseRule;
            if (responseCondition.getResponseIf() == null || responseCondition.getResponseElse() != null || (responseCondition.getResponseElseIfs() != null && responseCondition.getResponseElseIfs().size() > 0)) {
                continue;
            }
            ResponseIf responseIf = responseCondition.getResponseIf();
            List<ResponseRule> ifResponseRules = responseIf.getResponseRules();
            if (ifResponseRules == null || ifResponseRules.size() != 1 || !(ifResponseRules.get(0) instanceof SetOutcomeValue)) {
                continue;
            }
            SetOutcomeValue setOutcomeValue = (SetOutcomeValue) responseIf.getResponseRules().get(0);
            if (!findBaseValueInExpression(setOutcomeValue.getExpression(), feedback.getIdentifier())) {
                continue;
            }
            List<Expression> expressions = responseIf.getExpressions();
            if (expressions == null || expressions.size() != 1 || !(expressions.get(0) instanceof And)) {
                continue;
            }
            List<Variable> variables = QueryUtils.search(Variable.class, expressions.get(0));
            if (variables != null && variables.size() == 1) {
                Variable bValue = variables.get(0);
                ComplexReferenceIdentifier identifier = bValue.getIdentifier();
                if (identifier.equals(QTI21Constants.SCORE_CLX_IDENTIFIER) || identifier.equals(QTI21Constants.NUM_ATTEMPTS_CLX_IDENTIFIER)) {
                    return true;
                }
                if (identifier.equals(QTI21Constants.CORRECT_CLX_IDENTIFIER) || identifier.equals(QTI21Constants.INCORRECT_CLX_IDENTIFIER) || identifier.equals(QTI21Constants.EMPTY_CLX_IDENTIFIER)) {
                    return false;
                }
                String identifierToString = identifier.toString();
                if (identifierToString.contains("RESPONSE_")) {
                    return true;
                }
            }
        }
    }
    return false;
}