public void endElement(String uri, String localName, String qname) {
super.endElement(uri, localName, qname);
if (record != null && localName.equals(DataRecord.ENCODING_RECORD)) {
// end of record
if (dataImport.importRecord(record, fieldsInImport)) {
count++;
}
record = null;
fieldsInImport = null;
}
String fieldValue = getFieldValue();
if (record != null && fieldValue != null) {
// end of field
try {
if (textImport) {
if (!record.setFromText(fieldName, fieldValue.trim())) {
dataImport.logImportWarning(
record,
"Value '"
+ fieldValue
+ "' for Field '"
+ fieldName
+ "' corrected to '"
+ record.getAsText(fieldName)
+ "'");
}
} else {
record.set(fieldName, fieldValue.trim());
}
String[] equivFields = record.getEquivalentFields(fieldName);
for (String f : equivFields) {
fieldsInImport.add(f);
}
} catch (Exception esetvalue) {
dataImport.logImportWarning(
record,
"Cannot set value '"
+ fieldValue
+ "' for Field '"
+ fieldName
+ "': "
+ esetvalue.toString());
}
}
}
private void logImportFailed(DataRecord r, String msg, Exception e) {
if (e != null) {
Logger.logdebug(e);
}
logInfo(
"\nERROR: "
+ LogString.operationFailed(
International.getMessage("Import von Datensatz {record}", r.toString()), msg));
errorCount++;
}
protected static Object fieldValue(DapSequence seq, DataRecord record, String field)
throws DapException {
DapVariable dapv = seq.findByName(field);
if (dapv == null) throw new DapException("Unknown variable in filter: " + field);
if (dapv.getSort() != DapSort.ATOMICVARIABLE)
throw new DapException("Non-atomic variable in filter: " + field);
if (dapv.getRank() > 0) throw new DapException("Non-scalar variable in filter: " + field);
DataAtomic da = (DataAtomic) (record.readfield(field));
if (da == null) throw new DapException("No such field: " + field);
return da.read(0);
}
// TODO: Implement replace / addNew / replaceAll functionality
public void addDataRecord(DataRecord nRecord, boolean bAddNew, boolean bReplaceAll) {
// ISISAPI.IsisRecFieldUpdate(spaceHandler, 0, "a" );
String[] irComponents = nRecord.getIDRecord().split(Pattern.quote(DataRecord.getIDSeperator()));
String fieldCode = irComponents[0];
char subfieldCode = ' ';
if (irComponents.length > 1) {
subfieldCode = irComponents[1].charAt(0);
}
HashMap<Character, String> subfields = null;
if (this.writeBuffer.containsKey(fieldCode)) {
subfields = this.writeBuffer.get(fieldCode);
} else {
subfields = new HashMap<Character, String>();
}
subfields.put(subfieldCode, nRecord.getRecordContent());
this.writeBuffer.put(fieldCode, subfields);
}
/**
* Return a data record for a given IDRecord in the current entry
*
* @param IDRecord ID of record to return
* @return DataRecord with empty content if nothing found
*/
public DataRecord getDataRecord(String IDRecord) {
DataRecord rRecord = new DataRecord();
rRecord.setIDRecord(IDRecord);
rRecord.setRecordContent("");
String[] irComponents = IDRecord.split(Pattern.quote(DataRecord.getIDSeperator()));
String fieldCode = irComponents[0];
char subfieldCode = ' ';
if (irComponents.length > 1) {
subfieldCode = irComponents[1].charAt(0);
}
HashMap<Character, String> subfields = null;
if (this.writeBuffer.containsKey(fieldCode)) {
subfields = this.writeBuffer.get(fieldCode);
if (subfields.containsKey(subfieldCode)) {
rRecord.setRecordContent(subfields.get(subfieldCode));
}
}
return rRecord;
}
public int runCsvImport() {
int count = 0;
try {
int linecnt = 0;
String[] header = null;
ArrayList<String> fieldsInImport = new ArrayList<String>();
BufferedReader f =
new BufferedReader(new InputStreamReader(new FileInputStream(filename), encoding));
String s;
DataRecord dummyRecord = storageObject.createNewRecord();
while ((s = f.readLine()) != null) {
s = s.trim();
if (s.length() == 0) {
continue;
}
Vector<String> fields = splitFields(s);
if (fields.size() > 0) {
if (linecnt == 0) {
// header
header = new String[fields.size()];
for (int i = 0; i < fields.size(); i++) {
header[i] = fields.get(i);
if (header[i].startsWith("#") && header[i].endsWith("#") && header.length > 2) {
header[i] = header[i].substring(1, header[i].length() - 1).trim();
overrideKeyField = header[i];
}
String[] equivFields = dummyRecord.getEquivalentFields(header[i]);
for (String ef : equivFields) {
fieldsInImport.add(ef);
}
}
} else {
// fields
DataRecord r = storageObject.createNewRecord();
for (int i = 0; i < header.length; i++) {
String value = (fields.size() > i ? fields.get(i) : null);
if (value != null && value.length() > 0) {
try {
if (!r.setFromText(header[i], value.trim())) {
logImportWarning(
r,
"Value '"
+ value
+ "' for Field '"
+ header[i]
+ "' corrected to '"
+ r.getAsText(header[i])
+ "'");
}
} catch (Exception esetvalue) {
logImportWarning(
r,
"Cannot set value '"
+ value
+ "' for Field '"
+ header[i]
+ "': "
+ esetvalue.toString());
}
}
}
if (importRecord(r, fieldsInImport)) {
count++;
}
}
}
linecnt++;
}
f.close();
} catch (Exception e) {
logInfo(e.toString());
errorCount++;
Logger.log(e);
if (Daten.isGuiAppl()) {
Dialog.error(e.toString());
}
}
return count;
}
private boolean importRecord(DataRecord r, ArrayList<String> fieldsInInport) {
try {
if (Logger.isDebugLogging()) {
Logger.log(Logger.DEBUG, Logger.MSG_DEBUG_DATA, "importing " + r.toString());
}
DataRecord[] otherVersions = null;
if (importMode.equals(IMPORTMODE_ADD)
&& logbookEntryNoHandling != null
&& logbookEntryNoHandling.equals(ENTRYNO_ALWAYS_ADDEND)) {
// determine new EntryId for logbook
r.set(keyFields[0], ((Logbook) storageObject).getNextEntryNo());
}
if (isLogbook
&& (importMode.equals(IMPORTMODE_ADD) || importMode.equals(IMPORTMODE_ADDUPD))) {
LogbookRecord lr = ((LogbookRecord) r);
if (lr.getEntryId() == null
|| !lr.getEntryId().isSet()
|| lr.getEntryId().toString().length() == 0) {
r.set(keyFields[0], ((Logbook) storageObject).getNextEntryNo());
}
}
DataKey key = r.getKey();
if (key.getKeyPart1() == null || overrideKeyField != null) {
// first key field is *not* set, or we're overriding the default key field
DataKey[] keys = null;
if (overrideKeyField == null) {
// -> search for record by QualifiedName
keys =
dataAccess.getByFields(
r.getQualifiedNameFields(),
r.getQualifiedNameValues(r.getQualifiedName()),
(versionized ? validAt : -1));
} else {
// -> search for record by user-specified key field
keys =
dataAccess.getByFields(
new String[] {overrideKeyField},
new String[] {r.getAsString(overrideKeyField)},
(versionized ? validAt : -1));
}
if (keys != null && keys.length > 0) {
for (int i = 0; i < keyFields.length; i++) {
if (!keyFields[i].equals(DataRecord.VALIDFROM)) {
r.set(keyFields[i], keys[0].getKeyPart(i));
}
}
} else {
for (int i = 0; i < keyFields.length; i++) {
if (!keyFields[i].equals(DataRecord.VALIDFROM) && r.get(keyFields[i]) == null) {
if (dataAccess.getMetaData().getFieldType(keyFields[i]) == IDataAccess.DATA_UUID) {
r.set(keyFields[i], UUID.randomUUID());
} else {
logImportFailed(r, "KeyField(s) not set", null);
return false;
}
}
}
}
}
key = r.getKey();
if (versionized) {
otherVersions = dataAccess.getValidAny(key);
} else {
DataRecord r1 = dataAccess.get(key);
otherVersions = (r1 != null ? new DataRecord[] {r1} : null);
}
if (importMode.equals(IMPORTMODE_ADD)
&& otherVersions != null
&& otherVersions.length > 0
&& logbookEntryNoHandling != null
&& logbookEntryNoHandling.equals(ENTRYNO_DUPLICATE_ADDEND)) {
r.set(keyFields[0], ((Logbook) storageObject).getNextEntryNo());
otherVersions = null;
}
if (importMode.equals(IMPORTMODE_ADD)) {
if (otherVersions != null && otherVersions.length > 0) {
logImportFailed(r, International.getString("Datensatz existiert bereits"), null);
return false;
} else {
addRecord(r);
return true;
}
}
if (importMode.equals(IMPORTMODE_UPD)) {
if (otherVersions == null || otherVersions.length == 0) {
logImportFailed(r, International.getString("Datensatz nicht gefunden"), null);
return false;
} else {
updateRecord(r, fieldsInInport);
return true;
}
}
if (importMode.equals(IMPORTMODE_ADDUPD)) {
if (otherVersions != null && otherVersions.length > 0) {
updateRecord(r, fieldsInInport);
} else {
addRecord(r);
}
return true;
}
} catch (Exception e) {
logImportFailed(r, e.getMessage(), e);
}
return false;
}
private void updateRecord(DataRecord r, ArrayList<String> fieldsInInport) {
try {
DataRecord rorig =
(versionized ? dataAccess.getValidAt(r.getKey(), validAt) : dataAccess.get(r.getKey()));
if (rorig == null) {
logImportFailed(
r, International.getString("Keine gültige Version des Datensatzes gefunden."), null);
return;
}
// has the import record an InvalidFrom field?
long invalidFrom = (versionized ? getInvalidFrom(r) : -1);
if (invalidFrom <= rorig.getValidFrom()) {
invalidFrom = -1;
}
boolean changed = false;
for (int i = 0; i < fields.length; i++) {
Object o = r.get(fields[i]);
if ((o != null || fieldsInInport.contains(fields[i]))
&& !r.isKeyField(fields[i])
&& !fields[i].equals(DataRecord.LASTMODIFIED)
&& !fields[i].equals(DataRecord.VALIDFROM)
&& !fields[i].equals(DataRecord.INVALIDFROM)
&& !fields[i].equals(DataRecord.INVISIBLE)
&& !fields[i].equals(DataRecord.DELETED)) {
Object obefore = rorig.get(fields[i]);
rorig.set(fields[i], o);
if ((o != null && !o.equals(obefore)) || (o == null && obefore != null)) {
changed = true;
}
}
}
if (invalidFrom <= 0) {
long myValidAt = getValidFrom(r);
if (!versionized
|| updMode.equals(UPDMODE_UPDATEVALIDVERSION)
|| rorig.getValidFrom() == myValidAt) {
if (changed) {
dataAccess.update(rorig);
}
setCurrentWorkDone(++importCount);
}
if (versionized
&& updMode.equals(UPPMODE_CREATENEWVERSION)
&& rorig.getValidFrom() != myValidAt) {
if (changed) {
dataAccess.addValidAt(rorig, myValidAt);
}
setCurrentWorkDone(++importCount);
}
} else {
dataAccess.changeValidity(rorig, rorig.getValidFrom(), invalidFrom);
setCurrentWorkDone(++importCount);
}
} catch (Exception e) {
logImportFailed(r, e.toString(), e);
}
}
private long getInvalidFrom(DataRecord r) {
long rv = r.getInvalidFrom();
return (rv > 0 && rv < Long.MAX_VALUE ? rv : -1);
}
private long getValidFrom(DataRecord r) {
long rv = r.getValidFrom();
return (rv > 0 ? rv : validAt);
}
private void logImportWarning(DataRecord r, String msg) {
logInfo("\nWARNING: " + msg + ": " + r.toString());
warningCount++;
}
public void nextEntry() {
// Check if we are in read mode
if (this.controlStruct != null) {
String[] nextRecord = new String[1];
// System.out.println( "Reading Next Record: " + currIndex );
returnCode = ErrorCodes.ERR_RECPHYSDEL;
while (returnCode != ErrorCodes.ZERO) {
returnCode = ISISAPI.IsisRecRead(spaceHandler, 0, currIndex);
if (returnCode != ErrorCodes.ZERO) System.out.println("\nSkipping Record " + currIndex);
currIndex++;
}
returnCode = ISISAPI.IsisRecDump(spaceHandler, 0, nextRecord, Constants.MAXMFRL);
// Looks complicated, but we have to do it that way, because in Java we have no chance to
// convert a String object from a given encoding
// That's because the ISISAPI fills the string, and in java we can only convert encodings
// while filling the string object
byte[] rawData = new byte[nextRecord[0].length()];
for (int i = 0; i < nextRecord[0].length(); i++) {
rawData[i] = (byte) nextRecord[0].charAt(i);
}
String recordContent = "";
try {
recordContent = new String(rawData, this.fileEncoding);
} catch (Exception e) {
e.printStackTrace();
}
// Add the MFN-Number to the stack
// TODO Replace IDRecord once custom field adding is supported
DataRecord nRecord = new DataRecord();
nRecord.setIDRecord("001");
nRecord.setRecordContent(String.valueOf(currIndex - 1));
this.recordsStack.add(nRecord);
// this.charDecoder.decode( ByteBuffer.wrap( nextRecord[0] ) );
// String recordContent = new String( nextRecord[0].getBytes( this.fileEncoding ),
// this.fileEncoding );
Pattern p = Pattern.compile("<(\\d+)>(.*)</\\1>");
Matcher m = p.matcher(recordContent);
// temporary stack used for sorting
TreeMap<String, ArrayList<ArrayList<DataRecord>>> currRecordsStack =
new TreeMap<String, ArrayList<ArrayList<DataRecord>>>();
// parse & add all fields
while (m.find()) {
ArrayList<DataRecord> currFieldRecords = new ArrayList<DataRecord>();
// System.out.println( "Found: " + m.group(1) + " / Content: " + m.group(2) + " / " + (int)
// m.group(2).charAt(3) );
/*if( m.group(1).equals( "260$a" ) ) {
System.out.println( "DEBUG: " + m.group(1) + " Char: '" + m.group(1).charAt(3) + "'" );
}*/
// Convert to 3 digit code (required)
String fieldCode = String.format("%03d", Integer.valueOf(m.group(1)));
// String fieldCode = m.group(1);
// Add an entry for the whole record
nRecord = new DataRecord();
nRecord.setIDRecord(fieldCode);
nRecord.setRecordContent(m.group(2));
// this.recordsStack.add(nRecord);
currFieldRecords.add(nRecord);
// Find the sub-fields and add them to the stack
String[] subFields = m.group(2).split("\\^");
if (subFields.length > 1) {
for (int i = 1; i < subFields.length; i++) {
if (subFields[i].length() <= 0) continue;
nRecord = new DataRecord();
nRecord.setIDRecord(fieldCode + DataRecord.getIDSeperator() + subFields[i].charAt(0));
nRecord.setRecordContent(subFields[i].substring(1));
// this.recordsStack.add(nRecord);
currFieldRecords.add(nRecord);
}
}
Collections.sort(currFieldRecords);
// fetch fitting entry from temporary stack
ArrayList<ArrayList<DataRecord>> currRecordsStackEntry = currRecordsStack.get(fieldCode);
if (currRecordsStackEntry == null) {
currRecordsStackEntry = new ArrayList<ArrayList<DataRecord>>();
}
// add the new (sorted) record to the stack
currRecordsStackEntry.add(currFieldRecords);
currRecordsStack.put(fieldCode, currRecordsStackEntry);
}
// add the temporary stack to the internal recordsStack
// we use this as the entries are now correctly sorted
Iterator<Map.Entry<String, ArrayList<ArrayList<DataRecord>>>> crs_It =
currRecordsStack.entrySet().iterator();
while (crs_It.hasNext()) {
Map.Entry<String, ArrayList<ArrayList<DataRecord>>> currEntry = crs_It.next();
Iterator<ArrayList<DataRecord>> ce_It = currEntry.getValue().iterator();
while (ce_It.hasNext()) {
Iterator<DataRecord> dr_it = ce_It.next().iterator();
while (dr_it.hasNext()) {
this.recordsStack.add(dr_it.next());
}
}
}
// Sort collection by fieldID (refer to the compareTo implementation in DataRecord class)
// Collections.sort( this.recordsStack );
}
// Check if we are in write mode
else if (this.writeBuffer != null) {
String recordString = "";
Iterator<Map.Entry<String, HashMap<Character, String>>> wbIt =
this.writeBuffer.entrySet().iterator();
while (wbIt.hasNext()) {
Map.Entry<String, HashMap<Character, String>> currEntry = wbIt.next();
String fieldCode = currEntry.getKey();
HashMap<Character, String> subfields = currEntry.getValue();
String fieldString = "<" + fieldCode + ">";
Iterator<Map.Entry<Character, String>> sfIt = subfields.entrySet().iterator();
while (sfIt.hasNext()) {
Map.Entry<Character, String> currSfEntry = sfIt.next();
Character subfieldCode = currSfEntry.getKey();
String content = currSfEntry.getValue();
if (subfieldCode.equals(' ')) {
fieldString += content;
break;
} else {
fieldString += "^" + subfieldCode + content;
}
}
fieldString += "</" + fieldCode + ">\n";
recordString += fieldString;
}
returnCode = ISISAPI.IsisRecNew(spaceHandler, 0);
ISISAPI.IsisRecUpdate(spaceHandler, 0, recordString);
ISISAPI.IsisRecWrite(spaceHandler, 0);
this.writeBuffer = new HashMap<String, HashMap<Character, String>>();
}
}
protected void iniDialog() throws Exception {
// create GUI items
mainPanel.setLayout(new GridBagLayout());
ItemTypeLabel label1 =
new ItemTypeLabel(
"LABEL1",
IItemType.TYPE_PUBLIC,
"",
International.getMessage(
"Gültigkeitszeitraum von Version {version} ändern", version + 1));
label1.setPadding(0, 0, 0, 10);
label1.displayOnGui(this, mainPanel, 0, 0);
validFrom =
new ItemTypeDateTime(
"VALID_FROM",
(rCurrent.getValidFrom() == 0 ? null : new DataTypeDate(rCurrent.getValidFrom())),
(rCurrent.getValidFrom() == 0 ? null : new DataTypeTime(rCurrent.getValidFrom())),
IItemType.TYPE_PUBLIC,
"",
International.getString("gültig ab"));
validFrom.registerItemListener(this);
if (rPrev != null && rPrev.getValidFrom() != 0) {
validFrom.setMustBeAfter(
new ItemTypeDateTime(
"PREVRECORD_VALID_FROM",
new DataTypeDate(rPrev.getValidFrom()),
new DataTypeTime(rPrev.getValidFrom()),
IItemType.TYPE_INTERNAL,
"",
""),
false);
}
validFrom.setNotNull(rPrev != null);
validFrom.displayOnGui(this, mainPanel, 0, 1);
validFrom.requestFocus();
validUntil =
new ItemTypeDateTime(
"VALID_UNTIL",
(rCurrent.getInvalidFrom() == Long.MAX_VALUE
? null
: new DataTypeDate(rCurrent.getInvalidFrom() - 1)),
(rCurrent.getInvalidFrom() == Long.MAX_VALUE
? null
: new DataTypeTime(rCurrent.getInvalidFrom() - 1)),
IItemType.TYPE_PUBLIC,
"",
International.getString("gültig bis"));
validUntil.registerItemListener(this);
validUntil.setMustBeAfter(validFrom, true);
if (rNext != null && rNext.getInvalidFrom() != Long.MAX_VALUE) {
validUntil.setMustBeBefore(
new ItemTypeDateTime(
"NEXTRECORD_VALID_UNTIL",
new DataTypeDate(rNext.getInvalidFrom() - 1),
new DataTypeTime(rNext.getInvalidFrom() - 1),
IItemType.TYPE_INTERNAL,
"",
""),
false);
}
validUntil.setNotNull(rNext != null);
validUntil.displayOnGui(this, mainPanel, 0, 2);
closeButton.setIcon(getIcon(BaseDialog.IMAGE_ACCEPT));
closeButton.setIconTextGap(10);
}
