Examples with MapResponse uk.ac.ed.ph.jqtiplus.node.expression.general.MapResponse used on opensource projects

Example 1 with MapResponse

use of uk.ac.ed.ph.jqtiplus.node.expression.general.MapResponse in project OpenOLAT by OpenOLAT.

the class HotspotAssessmentItemBuilder method buildMainScoreRulePerAnswer.

private void buildMainScoreRulePerAnswer(ResponseCondition rule) {
    /*
		<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>
		*/
    // if no response
    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 variable = new Variable(isNull);
    variable.setIdentifier(ComplexReferenceIdentifier.parseString(responseIdentifier.toString()));
    isNull.getExpressions().add(variable);
    {
        // 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(hotspotInteraction.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);
    }
}

Example 2 with MapResponse

use of uk.ac.ed.ph.jqtiplus.node.expression.general.MapResponse in project OpenOLAT by OpenOLAT.

the class KPrimAssessmentItemBuilder method buildMainKPrimScoreRule.

/**
 * The score is 100% if 4 correct responses, 50% if 3 correct
 * responses and 0 otherwise.
 *
 * @param rule
 */
private void buildMainKPrimScoreRule(ResponseCondition rule) {
    /*
	<responseCondition>
		<responseIf>
			<isNull>
				<variable identifier="RESPONSE"/>
			</isNull>
			<setOutcomeValue identifier="SCORE">
				<baseValue baseType="float">0.0</baseValue>
			</setOutcomeValue>
		</responseIf>
		<responseElse>
			<setOutcomeValue identifier="SCORE">
				<mapResponse identifier="RESPONSE"/>
			</setOutcomeValue>
		</responseElse>
	</responseCondition>
		 */
    ResponseIf responseIf = new ResponseIf(rule);
    rule.setResponseIf(responseIf);
    {
        // if no response
        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 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.EMPTY_IDENTIFIER_VALUE);
        incorrectOutcomeValue.setExpression(incorrectValue);
    }
    ResponseElseIf responseElseIf = new ResponseElseIf(rule);
    rule.getResponseElseIfs().add(responseElseIf);
    {
        // match the correct answers -> 100%
        Match match = new Match(responseElseIf);
        responseElseIf.getExpressions().add(match);
        Variable scoreVar = new Variable(match);
        ComplexReferenceIdentifier choiceResponseIdentifier = ComplexReferenceIdentifier.parseString(matchInteraction.getResponseIdentifier().toString());
        scoreVar.setIdentifier(choiceResponseIdentifier);
        match.getExpressions().add(scoreVar);
        Correct correct = new Correct(match);
        correct.setIdentifier(choiceResponseIdentifier);
        match.getExpressions().add(correct);
    }
    {
        // outcome score
        SetOutcomeValue scoreOutcomeValue = new SetOutcomeValue(responseIf);
        scoreOutcomeValue.setIdentifier(QTI21Constants.SCORE_IDENTIFIER);
        responseElseIf.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);
    }
    {
        // set outcome
        SetOutcomeValue correctOutcomeValue = new SetOutcomeValue(responseIf);
        correctOutcomeValue.setIdentifier(QTI21Constants.FEEDBACKBASIC_IDENTIFIER);
        responseElseIf.getResponseRules().add(correctOutcomeValue);
        BaseValue correctValue = new BaseValue(correctOutcomeValue);
        correctValue.setBaseTypeAttrValue(BaseType.IDENTIFIER);
        correctValue.setSingleValue(QTI21Constants.CORRECT_IDENTIFIER_VALUE);
        correctOutcomeValue.setExpression(correctValue);
    }
    ResponseElse responseElse = new ResponseElse(rule);
    rule.setResponseElse(responseElse);
    /* Not perfect ->
		 	<setOutcomeValue identifier="SCORE">
          		<sum>
            		<mapResponse identifier="KPRIM_RESPONSE_1"/>
          		</sum>
        	</setOutcomeValue>
		*/
    {
        // outcome feedback
        SetOutcomeValue halfScoreOutcomeValue = new SetOutcomeValue(responseIf);
        halfScoreOutcomeValue.setIdentifier(QTI21Constants.SCORE_IDENTIFIER);
        responseElse.getResponseRules().add(halfScoreOutcomeValue);
        Sum sum = new Sum(halfScoreOutcomeValue);
        halfScoreOutcomeValue.setExpression(sum);
        MapResponse mapResponse = new MapResponse(sum);
        mapResponse.setIdentifier(responseIdentifier);
        sum.getExpressions().add(mapResponse);
        SetOutcomeValue incorrectOutcomeValue = new SetOutcomeValue(responseIf);
        incorrectOutcomeValue.setIdentifier(QTI21Constants.FEEDBACKBASIC_IDENTIFIER);
        responseElse.getResponseRules().add(incorrectOutcomeValue);
        BaseValue incorrectValue = new BaseValue(incorrectOutcomeValue);
        incorrectValue.setBaseTypeAttrValue(BaseType.IDENTIFIER);
        incorrectValue.setSingleValue(QTI21Constants.INCORRECT_IDENTIFIER_VALUE);
        incorrectOutcomeValue.setExpression(incorrectValue);
    }
}

Example 3 with MapResponse

use of uk.ac.ed.ph.jqtiplus.node.expression.general.MapResponse in project OpenOLAT by OpenOLAT.

the class HottextAssessmentItemBuilder method buildMainScoreRulePerAnswer.

private void buildMainScoreRulePerAnswer(ResponseCondition rule) {
    // simple as build with / without feedback
    ensureFeedbackBasicOutcomeDeclaration();
    /*
		<responseCondition>
			<responseIf>
				<match>
					<variable identifier="RESPONSE_1" />
					<correct identifier="RESPONSE_1" />
				</match>
				<setOutcomeValue identifier="SCORE">
					<sum>
						<variable identifier="SCORE" />
						<mapResponse identifier="RESPONSE_1" />
					</sum>
				</setOutcomeValue>
				<setOutcomeValue identifier="FEEDBACKBASIC">
					<baseValue baseType="identifier">correct</baseValue>
				</setOutcomeValue>
			</responseIf>
			<responseElse>
				<setOutcomeValue identifier="FEEDBACKBASIC">
					<baseValue baseType="identifier">incorrect</baseValue>
				</setOutcomeValue>
			</responseElse>
		</responseCondition>
		*/
    ResponseIf responseIf = new ResponseIf(rule);
    rule.setResponseIf(responseIf);
    {
        // match the correct answers
        matchCorrectAnswers(responseIf);
    }
    {
        // 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(hottextInteraction.getResponseIdentifier());
        sum.getExpressions().add(mapResponse);
    }
    {
        // outcome feedback
        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);
    }
    ResponseElse responseElse = new ResponseElse(rule);
    rule.setResponseElse(responseElse);
    {
        // outcome score
        SetOutcomeValue scoreOutcome = new SetOutcomeValue(responseElse);
        scoreOutcome.setIdentifier(QTI21Constants.SCORE_IDENTIFIER);
        responseElse.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(hottextInteraction.getResponseIdentifier());
        sum.getExpressions().add(mapResponse);
    }
    {
        // outcome feedback
        SetOutcomeValue incorrectOutcomeValue = new SetOutcomeValue(responseElse);
        incorrectOutcomeValue.setIdentifier(QTI21Constants.FEEDBACKBASIC_IDENTIFIER);
        responseElse.getResponseRules().add(incorrectOutcomeValue);
        BaseValue incorrectValue = new BaseValue(incorrectOutcomeValue);
        incorrectValue.setBaseTypeAttrValue(BaseType.IDENTIFIER);
        incorrectValue.setSingleValue(QTI21Constants.INCORRECT_IDENTIFIER_VALUE);
        incorrectOutcomeValue.setExpression(incorrectValue);
    }
}

Example 4 with MapResponse

use of uk.ac.ed.ph.jqtiplus.node.expression.general.MapResponse in project OpenOLAT by OpenOLAT.

the class SingleChoiceAssessmentItemBuilder method buildMainScoreRulePerAnswer.

private void buildMainScoreRulePerAnswer(ResponseCondition rule) {
    ensureFeedbackBasicOutcomeDeclaration();
    /*
		<responseCondition>
			<responseIf>
				<match>
					<variable identifier="RESPONSE_1" />
					<correct identifier="RESPONSE_1" />
				</match>
				<setOutcomeValue identifier="SCORE">
					<sum>
						<variable identifier="SCORE" />
						<mapResponse identifier="RESPONSE_1" />
					</sum>
				</setOutcomeValue>
				<setOutcomeValue identifier="FEEDBACKBASIC">
					<baseValue baseType="identifier">
						correct
					</baseValue>
				</setOutcomeValue>
			</responseIf>
		</responseCondition>
		 */
    ResponseIf responseIf = new ResponseIf(rule);
    rule.setResponseIf(responseIf);
    {
        // match the correct answer
        Match match = new Match(responseIf);
        responseIf.getExpressions().add(match);
        Variable responseVar = new Variable(match);
        ComplexReferenceIdentifier choiceResponseIdentifier = ComplexReferenceIdentifier.parseString(choiceInteraction.getResponseIdentifier().toString());
        responseVar.setIdentifier(choiceResponseIdentifier);
        match.getExpressions().add(responseVar);
        Correct correct = new Correct(match);
        correct.setIdentifier(choiceResponseIdentifier);
        match.getExpressions().add(correct);
    }
    {
        // 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 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);
    }
    ResponseElse responseElse = new ResponseElse(rule);
    rule.setResponseElse(responseElse);
    {
        // outcome score
        SetOutcomeValue scoreOutcome = new SetOutcomeValue(responseElse);
        scoreOutcome.setIdentifier(QTI21Constants.SCORE_IDENTIFIER);
        responseElse.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(responseElse);
        incorrectOutcomeValue.setIdentifier(QTI21Constants.FEEDBACKBASIC_IDENTIFIER);
        responseElse.getResponseRules().add(incorrectOutcomeValue);
        BaseValue incorrectValue = new BaseValue(incorrectOutcomeValue);
        incorrectValue.setBaseTypeAttrValue(BaseType.IDENTIFIER);
        incorrectValue.setSingleValue(QTI21Constants.INCORRECT_IDENTIFIER_VALUE);
        incorrectOutcomeValue.setExpression(incorrectValue);
    }
}

Example 5 with MapResponse

use of uk.ac.ed.ph.jqtiplus.node.expression.general.MapResponse in project openolat by klemens.

the class FIBAssessmentItemBuilder method buildMainScoreRuleAllCorrectAnswers.

private void buildMainScoreRuleAllCorrectAnswers(List<ResponseRule> responseRules) {
    /*
		<responseCondition>
			<responseIf>
				<and>
					<match>
						<value>-1.0</value>
						<correct identifier="RESPONSE_1" />
					</match>
					<equal toleranceMode="relative" tolerance="0.1 0.1" includeLowerBound="true" includeUpperBound="true">
						<correct identifier="RESPONSE_2" />
						<variable identifier="RESPONSE_2" />
					</equal>
				</and>
				<setOutcomeValue identifier="SCORE">
					<sum>
						<variable identifier="SCORE" />
						<variable identifier="MAXSCORE" />
					</sum>
				</setOutcomeValue>
				<setOutcomeValue identifier="FEEDBACKBASIC">
					<baseValue baseType="identifier">
						incorrect
					</baseValue>
				</setOutcomeValue>
			</responseIf>
		</responseCondition>
		*/
    // add condition
    ResponseCondition rule = new ResponseCondition(assessmentItem.getResponseProcessing());
    responseRules.add(0, rule);
    {
        // match all
        ResponseIf responseElseIf = new ResponseIf(rule);
        rule.setResponseIf(responseElseIf);
        // rule.getResponseElseIfs().add(responseElseIf);
        And and = new And(responseElseIf);
        responseElseIf.setExpression(and);
        for (Map.Entry<String, AbstractEntry> textEntryEntry : responseIdentifierToTextEntry.entrySet()) {
            AbstractEntry abstractEntry = textEntryEntry.getValue();
            if (abstractEntry instanceof TextEntry) {
                Match match = new Match(and);
                and.getExpressions().add(match);
                TextEntry textEntry = (TextEntry) abstractEntry;
                BaseValue variable = new BaseValue(match);
                variable.setBaseTypeAttrValue(BaseType.FLOAT);
                variable.setSingleValue(new FloatValue(-1.0d));
                match.getExpressions().add(variable);
                MapResponse correct = new MapResponse(match);
                correct.setIdentifier(textEntry.getResponseIdentifier());
                match.getExpressions().add(correct);
            } else if (abstractEntry instanceof NumericalEntry) {
                NumericalEntry numericalEntry = (NumericalEntry) abstractEntry;
                Equal equal = new Equal(and);
                equal.setToleranceMode(numericalEntry.getToleranceMode());
                if (numericalEntry.getLowerTolerance() != null && numericalEntry.getUpperTolerance() != null) {
                    List<FloatOrVariableRef> tolerances = new ArrayList<>();
                    tolerances.add(new FloatOrVariableRef(numericalEntry.getLowerTolerance().doubleValue()));
                    tolerances.add(new FloatOrVariableRef(numericalEntry.getUpperTolerance().doubleValue()));
                    equal.setTolerances(tolerances);
                }
                equal.setIncludeLowerBound(Boolean.TRUE);
                equal.setIncludeUpperBound(Boolean.TRUE);
                and.getExpressions().add(equal);
                ComplexReferenceIdentifier responseIdentifier = ComplexReferenceIdentifier.assumedLegal(numericalEntry.getResponseIdentifier().toString());
                Correct correct = new Correct(equal);
                correct.setIdentifier(responseIdentifier);
                equal.getExpressions().add(correct);
                Variable variable = new Variable(equal);
                variable.setIdentifier(responseIdentifier);
                equal.getExpressions().add(variable);
            }
        }
        {
            // outcome max score -> score
            SetOutcomeValue scoreOutcomeValue = new SetOutcomeValue(responseElseIf);
            scoreOutcomeValue.setIdentifier(QTI21Constants.SCORE_IDENTIFIER);
            responseElseIf.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);
        }
        {
            // outcome feedback
            SetOutcomeValue correctOutcomeValue = new SetOutcomeValue(responseElseIf);
            correctOutcomeValue.setIdentifier(QTI21Constants.FEEDBACKBASIC_IDENTIFIER);
            responseElseIf.getResponseRules().add(correctOutcomeValue);
            BaseValue correctValue = new BaseValue(correctOutcomeValue);
            correctValue.setBaseTypeAttrValue(BaseType.IDENTIFIER);
            correctValue.setSingleValue(QTI21Constants.CORRECT_IDENTIFIER_VALUE);
            correctOutcomeValue.setExpression(correctValue);
        }
    }
    {
        // else feedback incorrect
        ResponseElse responseElse = new ResponseElse(rule);
        rule.setResponseElse(responseElse);
        {
            // outcome feedback
            SetOutcomeValue correctOutcomeValue = new SetOutcomeValue(responseElse);
            correctOutcomeValue.setIdentifier(QTI21Constants.FEEDBACKBASIC_IDENTIFIER);
            responseElse.getResponseRules().add(correctOutcomeValue);
            BaseValue correctValue = new BaseValue(correctOutcomeValue);
            correctValue.setBaseTypeAttrValue(BaseType.IDENTIFIER);
            correctValue.setSingleValue(QTI21Constants.INCORRECT_IDENTIFIER_VALUE);
            correctOutcomeValue.setExpression(correctValue);
        }
    }
}