Examples with Not uk.ac.ed.ph.jqtiplus.node.expression.operator.Not used on opensource projects

Example 1 with Not

use of uk.ac.ed.ph.jqtiplus.node.expression.operator.Not 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 Not

use of uk.ac.ed.ph.jqtiplus.node.expression.operator.Not in project OpenOLAT by OpenOLAT.

the class LobAssessmentItemBuilder method buildMainEssayFeedbackRule.

private void buildMainEssayFeedbackRule(ResponseCondition rule) {
    /*
		 <responseCondition>
			<responseIf>
				<isNull>
					<variable identifier="RESPONSE_1" />
				</isNull>
				<setOutcomeValue identifier="FEEDBACKBASIC">
					<baseValue baseType="identifier">
						empty
					</baseValue>
				</setOutcomeValue>
			</responseIf>
		</responseCondition>
		 */
    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 feedbackOutcomeValue = new SetOutcomeValue(responseIf);
        feedbackOutcomeValue.setIdentifier(QTI21Constants.FEEDBACKBASIC_IDENTIFIER);
        responseIf.getResponseRules().add(feedbackOutcomeValue);
        BaseValue incorrectValue = new BaseValue(feedbackOutcomeValue);
        incorrectValue.setBaseTypeAttrValue(BaseType.IDENTIFIER);
        incorrectValue.setSingleValue(QTI21Constants.EMPTY_IDENTIFIER_VALUE);
        feedbackOutcomeValue.setExpression(incorrectValue);
    }
    ResponseElseIf responseElseIf = new ResponseElseIf(rule);
    rule.getResponseElseIfs().add(responseElseIf);
    {
        Not not = new Not(responseElseIf);
        responseElseIf.getExpressions().add(not);
        IsNull isNull = new IsNull(responseIf);
        not.getExpressions().add(isNull);
        Variable variable = new Variable(isNull);
        variable.setIdentifier(ComplexReferenceIdentifier.parseString(responseIdentifier.toString()));
        isNull.getExpressions().add(variable);
        SetOutcomeValue feedbackOutcomeValue = new SetOutcomeValue(responseIf);
        feedbackOutcomeValue.setIdentifier(QTI21Constants.FEEDBACKBASIC_IDENTIFIER);
        responseElseIf.getResponseRules().add(feedbackOutcomeValue);
        BaseValue answeredValue = new BaseValue(feedbackOutcomeValue);
        answeredValue.setBaseTypeAttrValue(BaseType.IDENTIFIER);
        answeredValue.setSingleValue(QTI21Constants.ANSWERED_IDENTIFIER_VALUE);
        feedbackOutcomeValue.setExpression(answeredValue);
    }
}

Example 3 with Not

use of uk.ac.ed.ph.jqtiplus.node.expression.operator.Not in project openolat by klemens.

the class LobAssessmentItemBuilder method buildMainEssayFeedbackRule.

private void buildMainEssayFeedbackRule(ResponseCondition rule) {
    /*
		 <responseCondition>
			<responseIf>
				<isNull>
					<variable identifier="RESPONSE_1" />
				</isNull>
				<setOutcomeValue identifier="FEEDBACKBASIC">
					<baseValue baseType="identifier">
						empty
					</baseValue>
				</setOutcomeValue>
			</responseIf>
		</responseCondition>
		 */
    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 feedbackOutcomeValue = new SetOutcomeValue(responseIf);
        feedbackOutcomeValue.setIdentifier(QTI21Constants.FEEDBACKBASIC_IDENTIFIER);
        responseIf.getResponseRules().add(feedbackOutcomeValue);
        BaseValue incorrectValue = new BaseValue(feedbackOutcomeValue);
        incorrectValue.setBaseTypeAttrValue(BaseType.IDENTIFIER);
        incorrectValue.setSingleValue(QTI21Constants.EMPTY_IDENTIFIER_VALUE);
        feedbackOutcomeValue.setExpression(incorrectValue);
    }
    ResponseElseIf responseElseIf = new ResponseElseIf(rule);
    rule.getResponseElseIfs().add(responseElseIf);
    {
        Not not = new Not(responseElseIf);
        responseElseIf.getExpressions().add(not);
        IsNull isNull = new IsNull(responseIf);
        not.getExpressions().add(isNull);
        Variable variable = new Variable(isNull);
        variable.setIdentifier(ComplexReferenceIdentifier.parseString(responseIdentifier.toString()));
        isNull.getExpressions().add(variable);
        SetOutcomeValue feedbackOutcomeValue = new SetOutcomeValue(responseIf);
        feedbackOutcomeValue.setIdentifier(QTI21Constants.FEEDBACKBASIC_IDENTIFIER);
        responseElseIf.getResponseRules().add(feedbackOutcomeValue);
        BaseValue answeredValue = new BaseValue(feedbackOutcomeValue);
        answeredValue.setBaseTypeAttrValue(BaseType.IDENTIFIER);
        answeredValue.setSingleValue(QTI21Constants.ANSWERED_IDENTIFIER_VALUE);
        feedbackOutcomeValue.setExpression(answeredValue);
    }
}

Example 4 with Not

use of uk.ac.ed.ph.jqtiplus.node.expression.operator.Not in project OpenOLAT by OpenOLAT.

the class AssessmentItemFactory method appendModalFeedbackCondition.

private static void appendModalFeedbackCondition(ModalFeedbackCondition condition, Identifier responseIdentifier, Cardinality cardinality, And and) {
    ModalFeedbackCondition.Variable var = condition.getVariable();
    ModalFeedbackCondition.Operator operator = condition.getOperator();
    String value = condition.getValue();
    if (var == ModalFeedbackCondition.Variable.response) {
        if (cardinality == Cardinality.MULTIPLE) {
            if (operator == ModalFeedbackCondition.Operator.equals) {
                Member member = new Member(and);
                and.getExpressions().add(member);
                appendVariableBaseValue(var, value, responseIdentifier, member, true);
            } else if (operator == ModalFeedbackCondition.Operator.notEquals) {
                Not not = new Not(and);
                and.getExpressions().add(not);
                Member member = new Member(not);
                not.getExpressions().add(member);
                appendVariableBaseValue(var, value, responseIdentifier, member, true);
            }
        } else {
            if (operator == ModalFeedbackCondition.Operator.equals) {
                Match match = new Match(and);
                and.getExpressions().add(match);
                appendVariableBaseValue(var, value, responseIdentifier, match, false);
            } else if (operator == ModalFeedbackCondition.Operator.notEquals) {
                Not not = new Not(and);
                and.getExpressions().add(not);
                Match match = new Match(not);
                not.getExpressions().add(match);
                appendVariableBaseValue(var, value, responseIdentifier, match, false);
            }
        }
    } else {
        switch(operator) {
            case bigger:
                {
                    Gt gt = new Gt(and);
                    and.getExpressions().add(gt);
                    appendVariableBaseValue(var, value, responseIdentifier, gt, false);
                    break;
                }
            case biggerEquals:
                {
                    Gte gte = new Gte(and);
                    and.getExpressions().add(gte);
                    appendVariableBaseValue(var, value, responseIdentifier, gte, false);
                    break;
                }
            case equals:
                {
                    Equal equal = new Equal(and);
                    equal.setToleranceMode(ToleranceMode.EXACT);
                    and.getExpressions().add(equal);
                    appendVariableBaseValue(var, value, responseIdentifier, equal, false);
                    break;
                }
            case notEquals:
                {
                    Not not = new Not(and);
                    and.getExpressions().add(not);
                    Equal equal = new Equal(not);
                    equal.setToleranceMode(ToleranceMode.EXACT);
                    not.getExpressions().add(equal);
                    appendVariableBaseValue(var, value, responseIdentifier, equal, false);
                    break;
                }
            case smaller:
                {
                    Lt lt = new Lt(and);
                    and.getExpressions().add(lt);
                    appendVariableBaseValue(var, value, responseIdentifier, lt, false);
                    break;
                }
            case smallerEquals:
                {
                    Lte lte = new Lte(and);
                    and.getExpressions().add(lte);
                    appendVariableBaseValue(var, value, responseIdentifier, lte, false);
                    break;
                }
        }
    }
}

Example 5 with Not

use of uk.ac.ed.ph.jqtiplus.node.expression.operator.Not in project OpenOLAT by OpenOLAT.

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;
}