/** * @throws QtiParseException if either value is not a valid identifier */ public AbstractPairValue(final String sourceValue, final String destValue) { this.sourceValue = Identifier.parseString(sourceValue); this.destValue = Identifier.parseString(destValue); }
@Override protected Identifier parseItemValue(final String value) { return Identifier.parseString(value); }
@Override public Identifier parseDomAttributeValue(final String domAttributeValue) { return Identifier.parseString(domAttributeValue); }
public IdentifierValue(final String value) { this(Identifier.parseString(value)); }
@Override public SingleValue parseSingleValue(final String string) { return new IdentifierValue(Identifier.parseString(string.trim())); } },
private static List<Identifier> parseOptionalIdentifierAttributeList(final Element element, final String identifierAttrListName) { final String identifierListAttrValue = element.getAttribute(identifierAttrListName); if (identifierListAttrValue.isEmpty()) { return Collections.emptyList(); } final String[] identifierArray = identifierListAttrValue.split("\\s+"); final List<Identifier> result = new ArrayList<Identifier>(identifierArray.length); for (final String identifierString : identifierArray) { try { result.add(Identifier.parseString(identifierString)); } catch (final QtiParseException e) { throw new XmlUnmarshallingException("Item '" + identifierString + "' extracted from value '" + identifierListAttrValue + "' of list attribute " + identifierAttrListName + " is not a valid QTI Identifier"); } } return result; } }
protected Map<Identifier, StringResponseData> extractStringResponseData(final HttpServletRequest httpServletRequest) { final Map<Identifier, StringResponseData> responseMap = new HashMap<Identifier, StringResponseData>(); @SuppressWarnings("unchecked") final Set<String> parameterNames = httpServletRequest.getParameterMap().keySet(); for (final String name : parameterNames) { if (name.startsWith("qtiworks_presented_")) { final String responseIdentifierString = name.substring("qtiworks_presented_".length()); final Identifier responseIdentifier; try { responseIdentifier = Identifier.parseString(responseIdentifierString); } catch (final QtiParseException e) { throw new BadResponseWebPayloadException("Bad response identifier encoded in parameter " + name, e); } final String[] responseValues = httpServletRequest.getParameterValues("qtiworks_response_" + responseIdentifierString); final StringResponseData stringResponseData = new StringResponseData(responseValues); responseMap.put(responseIdentifier, stringResponseData); } } return responseMap; }
public static TestPlanNodeKey fromString(final String string) { Assert.notNull(string); final Matcher matcher = keyPattern.matcher(string); if (!matcher.matches()) { throw new IllegalArgumentException(TestPlanNodeKey.class.getSimpleName() + " did not follow the expected pattern"); } final String identifierString = matcher.group(1); final Identifier identifier; try { identifier = Identifier.parseString(identifierString); } catch (final QtiParseException e) { throw new IllegalArgumentException("Bad identfifier " + identifierString + " within " + string); } final int abstractPartGlobalIndex = Integer.valueOf(matcher.group(2)); if (abstractPartGlobalIndex<0) { throw new IllegalArgumentException("Expected abstractPart global index " + abstractPartGlobalIndex + " in " + string + " to be non-negative"); } final int instanceNumber = Integer.valueOf(matcher.group(3)); if (instanceNumber<=0) { throw new IllegalArgumentException("Expected instance number " + instanceNumber + " in " + string + " to be strictly positive"); } return new TestPlanNodeKey(identifier, abstractPartGlobalIndex, instanceNumber); }
static Identifier parseIdentifierAttribute(final Element element, final String identifierAttrName) { final String identifierAttrValue = requireAttribute(element, identifierAttrName); try { return Identifier.parseString(identifierAttrValue); } catch (final QtiParseException e) { throw new XmlUnmarshallingException("Value " + identifierAttrValue + " of attribute " + identifierAttrName + " is not a valid QTI Identifier"); } }
public static Pair<Identifier, Identifier> parsePair(final String string) { Assert.notNull(string); final String[] parts = string.split(" ", 3); if (parts.length != 2) { throw new QtiParseException("Invalid pair '" + string + "': Number of parts is not valid"); } try { final Identifier first = Identifier.parseString(parts[0]); final Identifier second = Identifier.parseString(parts[1]); return new Pair<Identifier, Identifier>(first, second); } catch (final QtiParseException e) { throw new QtiParseException("Invalid pair '" + string + "'", e); } }
private static ItemSessionState createItemSessionState() { final ItemSessionState itemSessionState = new ItemSessionState(); final Map<Identifier, SingleValue> recordMap = new HashMap<Identifier, SingleValue>(); recordMap.put(Identifier.parseString("PMathML"), new StringValue("Hello")); recordMap.put(Identifier.parseString("Number"), new IntegerValue(5)); final Value rv = RecordValue.createRecordValue(recordMap); itemSessionState.setShuffledInteractionChoiceOrder(Identifier.parseString("dave"), Arrays.asList(Identifier.parseString("a"))); itemSessionState.setResponseValue(Identifier.parseString("RESPONSE"), MultipleValue.createMultipleValue(new StringValue("Bad"), new StringValue("Thing"))); itemSessionState.setTemplateValue(Identifier.parseString("TEMPLATE"), NullValue.INSTANCE); itemSessionState.setOutcomeValue(Identifier.parseString("RECORD"), rv); itemSessionState.setUnboundResponseIdentifiers(new HashSet<Identifier>(Arrays.asList(Identifier.assumedLegal("RESPONSE")))); itemSessionState.setRawResponseData(Identifier.assumedLegal("A"), new StringResponseData("1", "2")); return itemSessionState; }
public Value getTemplateValue(final String identifierString) { Assert.notNull(identifierString); return getTemplateValue(Identifier.parseString(identifierString)); }
public void setTemplateValue(final String identifierString, final Value value) { Assert.notNull(identifierString); setTemplateValue(Identifier.parseString(identifierString), value); }
/** * @throws QtiParseException */ public static StringOrVariableRef parseString(final String string) { Assert.notNull(string); if (string.isEmpty()) { throw new QtiParseException("stringOrVariableRef must not be empty"); } if (string.charAt(0)=='{' && string.charAt(string.length()-1)=='}') { /* It's a variable reference */ final Identifier variableReferenceIdentifier = Identifier.parseString(string.substring(1, string.length()-1)); return new StringOrVariableRef(variableReferenceIdentifier); } else { /* It's a string */ return new StringOrVariableRef(string); } }
protected Map<Identifier, MultipartFile> extractFileResponseData(final MultipartHttpServletRequest multipartRequest) { final Map<Identifier, MultipartFile> fileResponseMap = new HashMap<Identifier, MultipartFile>(); @SuppressWarnings("unchecked") final Set<String> parameterNames = multipartRequest.getParameterMap().keySet(); for (final String name : parameterNames) { if (name.startsWith("qtiworks_uploadpresented_")) { final String responseIdentifierString = name.substring("qtiworks_uploadpresented_".length()); final Identifier responseIdentifier; try { responseIdentifier = Identifier.parseString(responseIdentifierString); } catch (final QtiParseException e) { throw new BadResponseWebPayloadException("Bad response identifier encoded in parameter " + name, e); } final String multipartName = "qtiworks_uploadresponse_" + responseIdentifierString; final MultipartFile multipartFile = multipartRequest.getFile(multipartName); if (multipartFile==null) { throw new BadResponseWebPayloadException("Expected to find multipart file with name " + multipartName); } fileResponseMap.put(responseIdentifier, multipartFile); } } return fileResponseMap; }
public static RecordValue createRecordValue(final String identifier, final SingleValue value) { Assert.notNull(identifier, "identifier"); Assert.notNull(value, "value"); return new RecordValue(Identifier.parseString(identifier), value); }
/** * Parses a new floatOrVariableRef from the given String, as defined in the QTI spec. * * @throws QtiParseException */ public static FloatOrVariableRef parseString(final String string) { Assert.notNull(string); if (string.isEmpty()) { throw new QtiParseException("floatOrVariableRef must not be empty"); } try { /* Try to parse as a float */ final double floatValue = DataTypeBinder.parseFloat(string); return new FloatOrVariableRef(floatValue); } catch (final QtiParseException e) { /* Try to parse as a variable reference */ final Identifier variableReferenceIdentifier = Identifier.parseString(string); return new FloatOrVariableRef(variableReferenceIdentifier); } }
/** * Parses a new integerOrVariableRef from the given String, as defined in the QTI spec. * * @throws QtiParseException */ public static IntegerOrVariableRef parseString(final String string) { Assert.notNull(string); if (string.isEmpty()) { throw new QtiParseException("integerOrVariableRef must not be empty"); } try { /* Try to parse as in integer */ final int integer = DataTypeBinder.parseInteger(string); return new IntegerOrVariableRef(integer); } catch (final QtiParseException e) { /* Parse as a variable reference */ final Identifier variableReferenceIdentifier = Identifier.parseString(string); return new IntegerOrVariableRef(variableReferenceIdentifier); } }
private OutcomeVariable extractResultOutcomeVariable(final AssessmentResult assessmentResult, final Assessment assessment) { final AssessmentObjectType assessmentType = assessment.getAssessmentType(); final Identifier resultOutcomeIdentifier; try { resultOutcomeIdentifier = Identifier.parseString(assessment.getLtiResultOutcomeIdentifier()); } catch (final QtiParseException e) { return null; } switch (assessmentType) { case ASSESSMENT_ITEM: final List<ItemResult> itemResults = assessmentResult.getItemResults(); if (itemResults.size()!=1) { throw new QtiWorksLogicException("Expected exactly 1 itemResult within assessmentResult but got " + itemResults.size()); } final ItemResult itemResult = itemResults.get(0); final List<ItemVariable> itemVariables = itemResult.getItemVariables(); return extractOutcomeVariable(itemVariables, resultOutcomeIdentifier); case ASSESSMENT_TEST: final TestResult testResult = assessmentResult.getTestResult(); return extractOutcomeVariable(testResult.getItemVariables(), resultOutcomeIdentifier); default: throw new QtiWorksLogicException("Unexpected swtich casse: " + assessmentType); } }
public static void debugTestSessionState() { final TestSessionState testSessionState = new TestSessionState(createTestPlan()); testSessionState.setOutcomeValue(Identifier.parseString("SCORE"), new FloatValue(1)); for (final TestPlanNode itemRefNode : testSessionState.getTestPlan().searchNodes(TestNodeType.ASSESSMENT_ITEM_REF)) { testSessionState.getItemSessionStates().put(itemRefNode.getKey(), createItemSessionState()); } /* Marshal */ final Document document = TestSessionStateXmlMarshaller.marshal(testSessionState); final String serialized = serializeAndDumpDocument("Marshalled Test Session State", document); /* Unmarshal */ final TestSessionState parsed = TestSessionStateXmlMarshaller.unmarshal(serialized); System.out.println("Got back:\n" + ObjectDumper.dumpObject(parsed, DumpMode.DEEP)); } }