@Override public boolean isRecordChanged(RecordRef recordRef) { return updatedForms.contains(recordRef.getFormId()); } };
public TypedFormRecord(RecordRef recordRef) { this(recordRef.getRecordId(), recordRef.getFormId()); }
@Override public RecordHistory build(RecordRef recordRef) throws SQLException { Optional<FormStorage> form = catalog.getForm(recordRef.getFormId()); if(!form.isPresent()) { throw new FormNotFoundException(recordRef.getFormId()); } FormStorage formStorage = form.get(); if(formStorage instanceof VersionedFormStorage) { return getRecordHistory2((VersionedFormStorage) formStorage, recordRef); } else { return RecordHistory.unavailable(); } }
public FormInputModel updateSubForm(FormInputModel subFormInputModel) { assert !subFormInputModel.getRecordRef().getFormId().equals(this.recordRef.getFormId()) : "should only be used for sub input models, not the root input model"; Map<RecordRef, FormInputModel> updatedSubRecords = new HashMap<>(this.subRecords); updatedSubRecords.put(subFormInputModel.getRecordRef(), subFormInputModel); return new FormInputModel(this.recordRef, this.fieldInputs, updatedSubRecords, activeSubRecords, deletedSubRecords, touchedFields, validationRequested); }
public Observable<Map<LookupKey, String>> findKeyLabels(Observable<Set<RecordRef>> initialSelection) { return initialSelection.join(refs -> { List<Observable<Map<LookupKey, String>>> labels = new ArrayList<>(); for (RecordRef ref : refs) { KeyMatrix matrix = map.get(ref.getFormId()); if(matrix == null) { LOGGER.warning("Invalid selection for field. " + ref.getFormId() + " not in " + referenceType.getRange()); } else { labels.add(matrix.findKeyLabels(ref)); } } return Observable.flatten(labels).transform(maps -> { Map<LookupKey, String> merged = new HashMap<>(); for (Map<LookupKey, String> map : maps) { merged.putAll(map); } return merged; }); }); }
public RecordTree subTree(RecordRef ref) { return new RecordTree(formTree.subTree(ref.getFormId()), ref, this.relatedRecords, this.subRecords); }
private static Observable<Optional<SelectionViewModel>> compute(FormSource formSource, RecordRef ref) { Observable<FormTree> formTree = formSource.getFormTree(ref.getFormId()); Observable<Maybe<FormRecord>> record = formSource.getRecord(ref); return Observable.transform(formTree, record, SelectionViewModel::computeSelection); }
public RecordNode(RecordRef ref, Maybe<FormRecord> record) { this.ref = ref; this.formClass = formTree.getFormClass(ref.getFormId()); this.record = record.transform(r -> TypedFormRecord.toTypedFormRecord(formClass, r)); }
public static Observable<FormStructure> fetch(FormStore store, RecordRef ref) { Observable<FormTree> formTree = store.getFormTree(ref.getFormId()); Observable<Maybe<RecordTree>> existingRecord = store.getRecordTree(ref); return Observable.transform(formTree, existingRecord, FormStructure::new); } }
private Set<RecordRef> populateSelection(TypedFormRecord instance) { Set<RecordRef> parents = Sets.newHashSet(); Level level = hierarchy.getLevel(instance.getFormId()); if(level != null) { Choice choice = level.toChoice(instance); selection.put(choice.getRef().getFormId(), choice); if(!level.isRoot()) { parents.add(choice.getParentRef()); } } return parents; }
public FormRecord(RecordRef ref, String parentRecordId, JsonValue fields) { this.formId = ref.getFormId().asString(); this.recordId = ref.getRecordId().asString(); this.parentRecordId = parentRecordId; this.fields = fields; }
/** * If there is only one reference to a record in the given {@code formId}, then * return it's record id. Otherwise, return {@code null} */ @Nullable public String getOnlyRecordId(ResourceId formId) { String key = null; for (RecordRef id : references) { if(id.getFormId().equals(formId)) { // If this is not the first record referenced in the // form, then return null if(key != null) { return null; } key = id.getRecordId().asString(); } } return key; }
public HistoryRequest(RecordRef recordRef) { this.formId = recordRef.getFormId().asString(); this.recordId = recordRef.getRecordId().asString(); }
private Promise<Void> fetchLabelAndParentIds(final ResourceLocator locator, final Set<RecordRef> references) { List<Promise<Void>> promises = new ArrayList<>(); for (RecordRef reference : references) { promises.add(locator.getFormInstance(reference.getFormId(), reference.getRecordId()) .join(new Function<TypedFormRecord, Promise<Void>>() { @Nullable @Override public Promise<Void> apply(@Nullable TypedFormRecord instance) { Set<RecordRef> parentsToFetch = populateSelection(instance); if (parentsToFetch.isEmpty()) { return Promise.done(); } else { return fetchLabelAndParentIds(locator, parentsToFetch); } } })); } return Promise.waitAll(promises); }
public List<RecordUpdate> buildUpdates(RecordRef parentRef) { List<RecordUpdate> updates = new ArrayList<>(); for (FormInputViewModel subRecord : subRecords) { if(!subRecord.isPlaceholder()) { updates.add(subRecord.buildUpdate(Optional.of(parentRef))); } } for (RecordRef deletedRecord : deletedRecords) { RecordUpdate update = new RecordUpdate(); update.setFormId(deletedRecord.getFormId()); update.setRecordId(deletedRecord.getRecordId()); update.setDeleted(true); updates.add(update); } return updates; }
@Override public Promise<Maybe<FormRecord>> execute(ActivityInfoClientAsync client) { return client.getRecord(recordRef.getFormId().asString(), recordRef.getRecordId().asString()); }
@Override public Observable<Maybe<FormRecord>> getRecord(RecordRef recordRef) { return offlineStore.getCurrentSnapshot().join(snapshot -> { if(snapshot.isFormCached(recordRef.getFormId())) { return offlineStore.getCachedRecord(recordRef); } else { return httpStore.getRecord(recordRef); } }); }
@Override public Promise<Void> execute() { RecordTransactionBuilder tx = new RecordTransactionBuilder(); for (RecordRef recordRef : selection) { tx.delete(recordRef.getFormId(), recordRef.getRecordId()); } return formStore.updateRecords(tx.build()); }
@Override public void onNext(FieldValue fieldValue) { int count = 0; int key = -1; if(fieldValue instanceof ReferenceValue) { ReferenceValue referenceValue = (ReferenceValue) fieldValue; for (RecordRef id : referenceValue.getReferences()) { if(id.getFormId().equals(rightFormId)) { count++; key = keyId(id); } } } if(count == 1) { keys.add(key); } else { keys.add(-1); } }
@Override public Observable<Maybe<FormRecord>> getRecord(RecordRef recordRef) { return maybeExecute(() -> { Optional<FormStorage> storage = testingCatalog.getForm(recordRef.getFormId()); if(!storage.isPresent()) { return Maybe.notFound(); } Optional<FormRecord> record = storage.get().get(recordRef.getRecordId()); if(!record.isPresent()) { return Maybe.notFound(); } return Maybe.of(record.get()); }); }