use of uk.ac.ed.ph.jqtiplus.types.ComplexReferenceIdentifier 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);
}
}
}
use of uk.ac.ed.ph.jqtiplus.types.ComplexReferenceIdentifier in project openolat by klemens.
the class FIBAssessmentItemBuilder method extractNumericalEntrySettings.
private static boolean extractNumericalEntrySettings(NumericalEntry numericalEntry, Equal equal) {
Expression variableOrCorrect = equal.getExpressions().get(0);
Expression correctOrVariable = equal.getExpressions().get(1);
Correct correct = null;
if (variableOrCorrect instanceof Correct) {
correct = (Correct) variableOrCorrect;
} else if (correctOrVariable instanceof Correct) {
correct = (Correct) correctOrVariable;
}
ComplexReferenceIdentifier reponseIdentifer = ComplexReferenceIdentifier.assumedLegal(numericalEntry.getResponseIdentifier().toString());
if (correct != null && correct.getIdentifier().equals(reponseIdentifer)) {
numericalEntry.setToleranceMode(equal.getToleranceMode());
List<FloatOrVariableRef> tolerances = equal.getTolerances();
if (tolerances != null && tolerances.size() == 2) {
double lowerTolerance = tolerances.get(0).getConstantFloatValue().doubleValue();
numericalEntry.setLowerTolerance(lowerTolerance);
double upperTolerance = tolerances.get(1).getConstantFloatValue().doubleValue();
numericalEntry.setUpperTolerance(upperTolerance);
}
return true;
}
return false;
}
use of uk.ac.ed.ph.jqtiplus.types.ComplexReferenceIdentifier in project openolat by klemens.
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);
}
}
use of uk.ac.ed.ph.jqtiplus.types.ComplexReferenceIdentifier in project openolat by klemens.
the class MatchAssessmentItemBuilder method buildMainScoreRuleAllCorrectAnswers.
private void buildMainScoreRuleAllCorrectAnswers(ResponseCondition rule) {
/*
<responseCondition>
<responseIf>
<isNull>
<variable identifier="RESPONSE_1" />
</isNull>
<setOutcomeValue identifier="FEEDBACKBASIC">
<baseValue baseType="identifier">
empty
</baseValue>
</setOutcomeValue>
</responseIf>
<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>
<responseElse>
<setOutcomeValue identifier="FEEDBACKBASIC">
<baseValue baseType="identifier">
incorrect
</baseValue>
</setOutcomeValue>
</responseElse>
</responseCondition>
*/
// simple as build with / without feedback
ensureFeedbackBasicOutcomeDeclaration();
ResponseIf responseIf = new ResponseIf(rule);
rule.setResponseIf(responseIf);
// match the correct answers (or null if there are no associations)
if (associations.isEmpty()) {
IsNull isNull = new IsNull(responseIf);
responseIf.getExpressions().add(isNull);
Variable responseVar = new Variable(isNull);
ComplexReferenceIdentifier choiceResponseIdentifier = ComplexReferenceIdentifier.parseString(responseIdentifier.toString());
responseVar.setIdentifier(choiceResponseIdentifier);
isNull.getExpressions().add(responseVar);
} else {
Match match = new Match(responseIf);
responseIf.getExpressions().add(match);
Variable responseVar = new Variable(match);
ComplexReferenceIdentifier choiceResponseIdentifier = ComplexReferenceIdentifier.parseString(responseIdentifier.toString());
responseVar.setIdentifier(choiceResponseIdentifier);
match.getExpressions().add(responseVar);
Correct correct = new Correct(match);
correct.setIdentifier(choiceResponseIdentifier);
match.getExpressions().add(correct);
}
// outcome score + max score
appendSetOutcomeScoreMaxScore(responseIf);
// outcome correct feedback
appendSetOutcomeFeedbackCorrect(responseIf);
ResponseElse responseElse = new ResponseElse(rule);
rule.setResponseElse(responseElse);
// outcome incorrect feedback
appendSetOutcomeFeedbackIncorrect(responseElse);
}
use of uk.ac.ed.ph.jqtiplus.types.ComplexReferenceIdentifier in project openolat by klemens.
the class AssessmentItemChecker method checkSetCorrectResponse.
/**
* responseDeclaration -> float
*
* templateVraiable -> integer
*
* setCorrectResponse
* -> variable -> integer doesn't match float -> issue
* @param item
* @return
*/
private static boolean checkSetCorrectResponse(AssessmentItem item) {
boolean allOk = true;
List<SetCorrectResponse> setCorrectResponses = QueryUtils.search(SetCorrectResponse.class, item);
for (SetCorrectResponse setCorrectResponse : setCorrectResponses) {
Identifier responseIdentifier = setCorrectResponse.getIdentifier();
ResponseDeclaration responseDeclaration = item.getResponseDeclaration(responseIdentifier);
BaseType baseType = responseDeclaration.getBaseType();
Expression expression = setCorrectResponse.getExpression();
if (expression instanceof Variable) {
Variable variable = (Variable) expression;
ComplexReferenceIdentifier cpxVariableIdentifier = variable.getIdentifier();
Identifier variableIdentifier = Identifier.assumedLegal(cpxVariableIdentifier.toString());
TemplateDeclaration templateDeclaration = item.getTemplateDeclaration(variableIdentifier);
if (templateDeclaration != null && !templateDeclaration.hasBaseType(baseType)) {
templateDeclaration.setBaseType(baseType);
allOk &= false;
}
}
}
return allOk;
}
Aggregations