@Override public <T> T getField(String fieldName) throws FieldNotFoundException, RecordException { // The cast to (T) is only needed for a bug in JDK's < 1.6u24 return (T)delegate.getField(fieldName); }
@Override public <T> T getField(String fieldName) throws FieldNotFoundException, RecordException { // The cast to (T) is only needed for a bug in JDK's < 1.6u24 return (T)record.getField(fieldName); }
@Override public <T> T getField(QName fieldName) throws FieldNotFoundException { // The cast to (T) is only needed for a bug in JDK's < 1.6u24 return (T)delegate.getField(fieldName); }
@Override public <T> T getField(QName fieldName) throws FieldNotFoundException { return (T)record.getField(fieldName); }
@Override public <T> T getField(SchemaId fieldId) throws FieldNotFoundException { QName qname = mapping.get(fieldId); if (qname == null) { throw new FieldNotFoundException(fieldId); } // The cast to (T) is only needed for a bug in JDK's < 1.6u24 return (T)record.getField(qname); }
@Override public void beforeCreate(Record newRecord, Repository repository, FieldTypes fieldTypes, RecordEvent recordEvent) throws RepositoryException, InterruptedException { QName name = new QName("ns", "f1"); String currentValue = (String)newRecord.getField(name); newRecord.setField(name, currentValue + "-create-hook"); }
@Override public void beforeUpdate(Record record, Record originalRecord, Repository repository, FieldTypes fieldTypes, RecordEvent recordEvent) throws RepositoryException, InterruptedException { QName name = new QName("ns", "f1"); String currentValue = (String)record.getField(name); record.setField(name, currentValue + "-update-hook"); }
/** * Extracts the given field value from the record and transforms it into a flat (java) list, * regardless of the valueType of the field. * @param record * @param fieldType * @return */ public static List flatList(Record record, FieldType fieldType) { if (record != null && record.hasField(fieldType.getName())) { return flatList(record.getField(fieldType.getName()), fieldType.getValueType()); } else { return Collections.emptyList(); } }
return record.hasField(fieldType.getName()) && fieldValue.equals(record.getField(fieldType.getName())); } else if (fieldComparator == FieldComparator.NOT_EQUAL) { return !record.hasField(fieldType.getName()) || !fieldValue.equals(record.getField(fieldType.getName())); } else { throw new RuntimeException("Unexpected comparison operator: " + fieldComparator);
@Override public Object resolve(TemplatePart part) { RecordContext ctx = contexts.peek(); //TODO: add dependencies caused by resolving name template variables if (part instanceof FieldTemplatePart) { QName fieldName = ((FieldTemplatePart) part).getFieldType().getName(); if (ctx.record.hasField(fieldName)) { return ctx.record.getField(fieldName); } else { throw new NameTemplateEvaluationException( "Error evaluating name template: Record does not have field " + fieldName); } } else if (part instanceof VariantPropertyTemplatePart) { VariantPropertyTemplatePart vpPart = (VariantPropertyTemplatePart) part; return contexts.peek().contextRecord.getId().getVariantProperties().get(vpPart.getName()); } else if (part instanceof LiteralTemplatePart) { return ((LiteralTemplatePart) part).getString(); } else { throw new NameTemplateEvaluationException("Unsupported TemplatePart type " + part.getClass().getName()); } }
/** * Direct 'evaluation' (content extraction, formatting) of a given field * from a record. Should only be called if the field is present in the * record. */ public List<String> format(String table, Record record, FieldType fieldType, boolean extractContent, String formatterName, LRepository repository) throws InterruptedException { Object value = record.getField(fieldType.getName()); List<IndexValue> indexValues; if (fieldType.getValueType().getBaseName().equals("LIST")) { List<Object> values = (List<Object>) value; indexValues = new ArrayList<IndexValue>(values.size()); for (int i = 0; i < values.size(); i++) { indexValues.add(new IndexValue(record, fieldType, i, values.get(i))); } } else { indexValues = Collections.singletonList(new IndexValue(record, fieldType, value)); } if (fieldType.getValueType().getDeepestValueType().getBaseName().equals("BLOB") && extractContent) { return extractContent(table, indexValues, repository); } Formatter formatter = conf.getFormatters().getFormatter(formatterName); return formatter.format(indexValues, repository); }
/** * Returns null if the vtag does not exist or is not defined for the record. */ public static Record getRecord(RecordId recordId, String vtag, List<QName> fields, LTable table, LRepository repository) throws RepositoryException, InterruptedException { QName vtagName = new QName(NAMESPACE, vtag); Record record = table.read(recordId); long version; if (vtag.equals("last")) { // we loaded the last version if (fields != null) { filterFields(record, new HashSet<QName>(fields)); } return record; } else if (!record.hasField(vtagName)) { return null; } else { version = (Long) record.getField(vtagName); if (version == 0) { reduceToNonVersioned(record, fields != null ? new HashSet<QName>(fields) : null, repository.getTypeManager()); } else { record = table.read(recordId, version, fields); } return record; } }
private Blob getBlobFromRecord(Record record, QName fieldName, FieldType fieldType, int... indexes) throws BlobNotFoundException { Object value = record.getField(fieldName); ValueType valueType = fieldType.getValueType(); if (!valueType.getDeepestValueType().getBaseName().equals("BLOB")) {
blobValue = originalRecord.getField(fieldType.getName());
private Object getValue(IndexUpdateBuilder indexUpdateBuilder, FieldType fieldType) throws RepositoryException, InterruptedException { Object value = null; Record record = indexUpdateBuilder.getRecordContext().record; if (systemFields.isSystemField(fieldType.getName())) { if (record != null) { value = systemFields.eval(record, fieldType, indexUpdateBuilder.getRepository().getTypeManager()); } } else { indexUpdateBuilder.addDependency(fieldType.getId()); if (record != null && record.hasField(fieldType.getName())) { value = record.getField(fieldType.getName()); } } return value; }
@Override public void beforeDelete(Record originalRecord, Repository repository, FieldTypes fieldTypes, RecordEvent recordEvent) throws RepositoryException, InterruptedException { Collection<IndexInfo> indexInfos = indexesInfo.getIndexInfos(); if (indexInfos.size() > 0) { TypeManager typeMgr = repository.getTypeManager(); RecordEvent.IndexRecordFilterData idxSel = new RecordEvent.IndexRecordFilterData(); recordEvent.setIndexRecordFilterData(idxSel); idxSel.setOldRecordExists(true); idxSel.setNewRecordExists(false); if (indexesInfo.getRecordFilterDependsOnRecordType()) { idxSel.setOldRecordType(typeMgr.getRecordTypeByName(originalRecord.getRecordTypeName(), null).getId()); } Set<QName> names = indexesInfo.getRecordFilterFieldDependencies(); for (QName name : names) { if (originalRecord.hasField(name)) { Object oldValue = originalRecord.getField(name); FieldType type = fieldTypes.getFieldType(name); addField(type, oldValue, null, idxSel); } } calculateIndexInclusion(repository.getRepositoryName(), recordEvent.getTableName(), originalRecord, null, idxSel); } }
@Override public void beforeCreate(Record newRecord, Repository repository, FieldTypes fieldTypes, RecordEvent recordEvent) throws RepositoryException, InterruptedException { Collection<IndexInfo> indexInfos = indexesInfo.getIndexInfos(); if (indexInfos.size() > 0) { TypeManager typeMgr = repository.getTypeManager(); RecordEvent.IndexRecordFilterData idxSel = new RecordEvent.IndexRecordFilterData(); recordEvent.setIndexRecordFilterData(idxSel); idxSel.setOldRecordExists(false); idxSel.setNewRecordExists(true); if (indexesInfo.getRecordFilterDependsOnRecordType()) { idxSel.setNewRecordType(typeMgr.getRecordTypeByName(newRecord.getRecordTypeName(), null).getId()); } Set<QName> names = indexesInfo.getRecordFilterFieldDependencies(); for (QName name : names) { if (newRecord.hasField(name)) { Object newValue = newRecord.getField(name); FieldType type = fieldTypes.getFieldType(name); addField(type, null, newValue, idxSel); } } calculateIndexInclusion(repository.getRepositoryName(), recordEvent.getTableName(), null, newRecord, idxSel); } }