@Override public boolean hasField(String fieldName) throws RecordException { return record.hasField(fieldName); }
@Override public boolean hasField(QName fieldName) { return record.hasField(fieldName); }
@Override public boolean hasField(QName fieldName) { return delegate.hasField(fieldName); }
@Override public boolean hasField(String fieldName) throws RecordException { return delegate.hasField(fieldName); }
@Override public boolean hasField(SchemaId fieldId) { QName qname = mapping.get(fieldId); if (qname == null) { return false; } // Normally, we will only have a mapping for fields which are actually in the record, // but just to be sure: return record.hasField(qname); }
/** * 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()); } }
/** * 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 void validateRecord(Record record, Record originalRecord, RecordType recordType, FieldTypes fieldTypes) throws TypeException, InvalidRecordException, InterruptedException { // Check mandatory fields Collection<FieldTypeEntry> fieldTypeEntries = recordType.getFieldTypeEntries(); List<QName> fieldsToDelete = record.getFieldsToDelete(); for (FieldTypeEntry fieldTypeEntry : fieldTypeEntries) { if (fieldTypeEntry.isMandatory()) { FieldType fieldType = fieldTypes.getFieldType(fieldTypeEntry.getFieldTypeId()); QName fieldName = fieldType.getName(); if (fieldsToDelete.contains(fieldName)) { throw new InvalidRecordException("Field: '" + fieldName + "' is mandatory.", record.getId()); } if (!record.hasField(fieldName) && !originalRecord.hasField(fieldName)) { throw new InvalidRecordException("Field: '" + fieldName + "' is mandatory.", record.getId()); } } } }
private void validateRecord(Record record, Record originalRecord, RecordType recordType) throws TypeException, InvalidRecordException, InterruptedException, RepositoryException { // Check mandatory fields Collection<FieldTypeEntry> fieldTypeEntries = recordType.getFieldTypeEntries(); List<QName> fieldsToDelete = record.getFieldsToDelete(); for (FieldTypeEntry fieldTypeEntry : fieldTypeEntries) { if (fieldTypeEntry.isMandatory()) { FieldType fieldType = getTypeManager().getFieldTypeById(fieldTypeEntry.getFieldTypeId()); QName fieldName = fieldType.getName(); if (fieldsToDelete.contains(fieldName)) { throw new InvalidRecordException("Field: '" + fieldName + "' is mandatory.", record.getId()); } if (!record.hasField(fieldName) && !originalRecord.hasField(fieldName)) { throw new InvalidRecordException("Field: '" + fieldName + "' is mandatory.", record.getId()); } } } }
@Override public void collectIndexUpdate(final IndexUpdateBuilder indexUpdateBuilder) throws InterruptedException, IOException, RepositoryException { RecordContext ctx = indexUpdateBuilder.getRecordContext(); if (fieldType != null && !systemFields.isSystemField(fieldType.getName())) { indexUpdateBuilder.addDependency(fieldType.getId()); if (ctx.record != null && !ctx.record.hasField(fieldType.getName())) { return; } } follow.follow(indexUpdateBuilder, new FollowCallback() { @Override public void call() throws RepositoryException, InterruptedException, IOException { ForEachNode.super.collectIndexUpdate(indexUpdateBuilder); } }); }
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 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); } }
@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); } }