br.ufrj.ppgi.greco.kettle.DataPropertyMappingStepMeta.isThereAdditionalSubjectOutputField() - Code Metrics - johncurcio/ETL4LODPlus - Measure and Improve Code Quality continuously with Scrutinizer

isThereAdditionalSubjectOutputField() A
last analyzed 2019-10-13 02:26 UTC

↳ Parent: br.ufrj.ppgi.greco.kettle.DataPropertyMappingStepMeta

Complexity

Conditions

Size

Total Lines	3
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
eloc	3
c	1
b	0
f	1
dl	0
loc	3
rs	10
cc	1

package br.ufrj.ppgi.greco.kettle;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import org.pentaho.di.core.CheckResult;
import org.pentaho.di.core.CheckResultInterface;
import org.pentaho.di.core.Counter;
import org.pentaho.di.core.database.DatabaseMeta;
import org.pentaho.di.core.exception.KettleException;
import org.pentaho.di.core.exception.KettleStepException;
import org.pentaho.di.core.exception.KettleXMLException;
import org.pentaho.di.core.row.RowMetaInterface;
import org.pentaho.di.core.row.ValueMetaInterface;
import org.pentaho.di.core.row.value.ValueMetaString;
import org.pentaho.di.core.variables.VariableSpace;
import org.pentaho.di.core.xml.XMLHandler;
import org.pentaho.di.repository.ObjectId;
import org.pentaho.di.repository.Repository;
import org.pentaho.di.trans.Trans;
import org.pentaho.di.trans.TransMeta;
import org.pentaho.di.trans.step.BaseStepMeta;
import org.pentaho.di.trans.step.StepDataInterface;
import org.pentaho.di.trans.step.StepInterface;
import org.pentaho.di.trans.step.StepMeta;
import org.pentaho.di.trans.step.StepMetaInterface;
import org.w3c.dom.Node;

import br.ufrj.ppgi.greco.kettle.plugin.tools.datatable.DataTable;
import br.ufrj.ppgi.greco.kettle.plugin.tools.datatable.DataTableConverter;

import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.io.xml.DomDriver;

public class DataPropertyMappingStepMeta extends BaseStepMeta implements StepMetaInterface {
	// Fields for serialization
	public enum Field {
		DATA_ROOT_NODE, VERSION,

		// Aba 'Mapeamento'
		RDF_TYPE_URIS, SUBJECT_URI_FIELD_NAME, MAP_TABLE, MAP_TABLE_PREDICATE_FIELD_NAME, MAP_TABLE_PREDICATE_URI, MAP_TABLE_OBJECT_FIELD_NAME, MAP_TABLE_TYPED_LITERAL, MAP_TABLE_LANGUAGE_TAG, MAP_TABLE_LANGTAG_FIELD_NAME,

		// Aba 'Campos de saida'
		SUBJECT_OUT_FIELD_NAME, PREDICATE_OUT_FIELD_NAME, OBJECT_OUT_FIELD_NAME, DATATYPE_OUT_FIELD_NAME, LANGTAG_OUT_FIELD_NAME, KEEP_INPUT_FIELDS,

		// Aba 'Sparql Endpoint' - no futuro
		ENDPOINT_URI, DEFAULT_GRAPH, PREFIX_TABLE, PREFIX_TABLE_PREFIX, PREFIX_TABLE_NAMESPACE
	}

	// Campos do step
	private List<String> rdfTypeUris;
	private String subjectUriFieldName;
	private DataTable<String> mapTable;

	private String subjectOutputFieldName;
	private String predicateOutputFieldName;
	private String objectOutputFieldName;
	private String datatypeOutputFieldName;
	private String langTagOutputFieldName;
	private boolean keepInputFields;

	// private String endpointUri;
	// private String defaultGraph;
	// private DataTable<String> prefixes;

	public DataPropertyMappingStepMeta() {
		setDefault();
	}

	// TODO Validar todos os campos para dar feedback ao usuario!
	@Override
	public void check(List<CheckResultInterface> remarks, TransMeta transMeta, StepMeta stepMeta, RowMetaInterface prev,
			String[] input, String[] output, RowMetaInterface info) {
		CheckResultInterface ok = new CheckResult(CheckResult.TYPE_RESULT_OK, "", stepMeta);
		remarks.add(ok);
	}

	public StepInterface getStep(StepMeta stepMeta, StepDataInterface stepDataInterface, int copyNr,
			TransMeta transMeta, Trans trans) {
		return new DataPropertyMappingStep(stepMeta, stepDataInterface, copyNr, transMeta, trans);
	}

	public StepDataInterface getStepData() {
		return new DataPropertyMappingStepData();
	}

	@Override
	public String getDialogClassName() {
		return DataPropertyMappingStepDialog.class.getName();
	}

	@SuppressWarnings("unchecked")
	@Override
	public void loadXML(Node stepDomNode, List<DatabaseMeta> databases, Map<String, Counter> sequenceCounters)
			throws KettleXMLException {
		try {
			XStream xs = new XStream(new DomDriver());
			xs.alias("DataTable", DataTable.class);
			xs.registerConverter(new DataTableConverter());
			
			rdfTypeUris = (List<String>) xs.fromXML(XMLHandler.getTagValue(stepDomNode, Field.RDF_TYPE_URIS.name()));
			subjectUriFieldName = (String) XMLHandler.getTagValue(stepDomNode, Field.SUBJECT_URI_FIELD_NAME.name());
			mapTable = (DataTable<String>) xs.fromXML(XMLHandler.getTagValue(stepDomNode, Field.MAP_TABLE.name()));
			subjectOutputFieldName = (String) XMLHandler.getTagValue(stepDomNode, Field.SUBJECT_OUT_FIELD_NAME.name());
			predicateOutputFieldName = (String) XMLHandler.getTagValue(stepDomNode, Field.PREDICATE_OUT_FIELD_NAME.name());
			objectOutputFieldName = (String) XMLHandler.getTagValue(stepDomNode, Field.OBJECT_OUT_FIELD_NAME.name());
			datatypeOutputFieldName = (String) XMLHandler.getTagValue(stepDomNode, Field.DATATYPE_OUT_FIELD_NAME.name());
			langTagOutputFieldName = (String) XMLHandler.getTagValue(stepDomNode, Field.LANGTAG_OUT_FIELD_NAME.name());
			keepInputFields = Boolean.valueOf(XMLHandler.getTagValue(stepDomNode, Field.KEEP_INPUT_FIELDS.name()));
			
		} catch (Throwable e) {
			e.printStackTrace();
		}
	}

	@Override
	public String getXML() throws KettleException {
		XStream xs = new XStream(new DomDriver());
		xs.alias("DataTable", DataTable.class);
		xs.registerConverter(new DataTableConverter());
		
		StringBuilder xml = new StringBuilder();
		
		xml.append(XMLHandler.addTagValue(Field.RDF_TYPE_URIS.name(), xs.toXML(rdfTypeUris)));
		xml.append(XMLHandler.addTagValue(Field.SUBJECT_URI_FIELD_NAME.name(), subjectUriFieldName));
		xml.append(XMLHandler.addTagValue(Field.MAP_TABLE.name(), xs.toXML(mapTable)));
		xml.append(XMLHandler.addTagValue(Field.SUBJECT_OUT_FIELD_NAME.name(), subjectOutputFieldName));
		xml.append(XMLHandler.addTagValue(Field.PREDICATE_OUT_FIELD_NAME.name(), predicateOutputFieldName));
		xml.append(XMLHandler.addTagValue(Field.OBJECT_OUT_FIELD_NAME.name(), objectOutputFieldName));
		xml.append(XMLHandler.addTagValue(Field.DATATYPE_OUT_FIELD_NAME.name(), datatypeOutputFieldName));
		xml.append(XMLHandler.addTagValue(Field.LANGTAG_OUT_FIELD_NAME.name(), langTagOutputFieldName));
		xml.append(XMLHandler.addTagValue(Field.KEEP_INPUT_FIELDS.name(), keepInputFields));

		return xml.toString();
	}

	@Override
	public void readRep(Repository repository, ObjectId stepIdInRepository, List<DatabaseMeta> databases,
			Map<String, Counter> sequenceCounters) throws KettleException {
		int version = (int) repository.getStepAttributeInteger(stepIdInRepository, Field.VERSION.name());

		switch (version) {
		case 3:
			langTagOutputFieldName = repository.getStepAttributeString(stepIdInRepository,
					Field.LANGTAG_OUT_FIELD_NAME.name());
		case 2:
			datatypeOutputFieldName = repository.getStepAttributeString(stepIdInRepository,
					Field.DATATYPE_OUT_FIELD_NAME.name());
		case 1:
			int nrRdfTypeUris = (int) repository.countNrStepAttributes(stepIdInRepository, Field.RDF_TYPE_URIS.name());
			rdfTypeUris = new ArrayList<String>();
			for (int i = 0; i < nrRdfTypeUris; i++) {
				String item = repository.getStepAttributeString(stepIdInRepository, i, Field.RDF_TYPE_URIS.name());
				rdfTypeUris.add(item);
			}
			subjectUriFieldName = repository.getStepAttributeString(stepIdInRepository,
					Field.SUBJECT_URI_FIELD_NAME.name());
			int nrLines = (int) repository.getStepAttributeInteger(stepIdInRepository, "nr_lines");
			mapTable = new DataTable<String>(Field.MAP_TABLE.name(), Field.MAP_TABLE_PREDICATE_FIELD_NAME.name(),
					Field.MAP_TABLE_PREDICATE_URI.name(), Field.MAP_TABLE_OBJECT_FIELD_NAME.name(),
					Field.MAP_TABLE_TYPED_LITERAL.name(), Field.MAP_TABLE_LANGUAGE_TAG.name(),
					Field.MAP_TABLE_LANGTAG_FIELD_NAME.name());
			String[] fields = mapTable.getHeader().toArray(new String[0]);
			/*
			 * { Field.MAP_TABLE_PREDICATE_FIELD_NAME.name(),
			 * Field.MAP_TABLE_PREDICATE_URI.name(),
			 * Field.MAP_TABLE_OBJECT_FIELD_NAME.name(),
			 * Field.MAP_TABLE_TYPED_LITERAL.name(),
			 * Field.MAP_TABLE_LANGUAGE_TAG.name(),
			 * Field.MAP_TABLE_LANGTAG_FIELD_NAME.name() };
			 */
			for (int i = 0; i < nrLines; i++) {

				int nrfields = fields.length;
				String[] line = new String[nrfields];

				for (int f = 0; f < nrfields; f++) {
					line[f] = repository.getStepAttributeString(stepIdInRepository, i, fields[f]);
				}
				mapTable.add(line);
			}
			subjectOutputFieldName = repository.getStepAttributeString(stepIdInRepository,
					Field.SUBJECT_OUT_FIELD_NAME.name());
			predicateOutputFieldName = repository.getStepAttributeString(stepIdInRepository,
					Field.PREDICATE_OUT_FIELD_NAME.name());
			objectOutputFieldName = repository.getStepAttributeString(stepIdInRepository,
					Field.OBJECT_OUT_FIELD_NAME.name());
			keepInputFields = repository.getStepAttributeBoolean(stepIdInRepository, Field.KEEP_INPUT_FIELDS.name());
			break;
		default:
			setDefault();
		}
	}

	@Override

	public void saveRep(Repository repository, ObjectId idOfTransformation, ObjectId idOfStep) throws KettleException {
		try {
			repository.saveStepAttribute(idOfTransformation, idOfStep, Field.VERSION.name(), 3);
			repository.saveStepAttribute(idOfTransformation, idOfStep, Field.LANGTAG_OUT_FIELD_NAME.name(),
					langTagOutputFieldName);
			repository.saveStepAttribute(idOfTransformation, idOfStep, Field.DATATYPE_OUT_FIELD_NAME.name(),
					datatypeOutputFieldName);
			repository.saveStepAttribute(idOfTransformation, idOfStep, Field.SUBJECT_URI_FIELD_NAME.name(),
					subjectUriFieldName);
			repository.saveStepAttribute(idOfTransformation, idOfStep, Field.SUBJECT_OUT_FIELD_NAME.name(),
					subjectOutputFieldName);
			repository.saveStepAttribute(idOfTransformation, idOfStep, Field.PREDICATE_OUT_FIELD_NAME.name(),
					predicateOutputFieldName);
			repository.saveStepAttribute(idOfTransformation, idOfStep, Field.OBJECT_OUT_FIELD_NAME.name(),
					objectOutputFieldName);
			repository.saveStepAttribute(idOfTransformation, idOfStep, Field.KEEP_INPUT_FIELDS.name(), keepInputFields);

			// Lista de RDF Type URIs
			for (int i = 0; i < rdfTypeUris.size(); i++) {
				repository.saveStepAttribute(idOfTransformation, idOfStep, i, Field.RDF_TYPE_URIS.name(),
						rdfTypeUris.get(i));
			}

			// Map Table
			int linhas = (int) mapTable.size();
			int colunas = mapTable.getHeader().size();
			repository.saveStepAttribute(idOfTransformation, idOfStep, "nr_lines", linhas);
			for (int i = 0; i < linhas; i++) {
				for (int f = 0; f < colunas; f++) {
					repository.saveStepAttribute(idOfTransformation, idOfStep, i, mapTable.getHeader().get(f),
							mapTable.getValue(i, f));
				}
			}
		} catch (Exception e) {
			throw new KettleException("Unable to save step information to the repository for id_step=" + idOfStep, e);
		}
	}

	public void setDefault() {
		rdfTypeUris = new ArrayList<String>();
		subjectUriFieldName = "";
		mapTable = new DataTable<String>(Field.MAP_TABLE.name(), Field.MAP_TABLE_PREDICATE_FIELD_NAME.name(),
				Field.MAP_TABLE_PREDICATE_URI.name(), Field.MAP_TABLE_OBJECT_FIELD_NAME.name(),
				Field.MAP_TABLE_TYPED_LITERAL.name(), Field.MAP_TABLE_LANGUAGE_TAG.name(),
				Field.MAP_TABLE_LANGTAG_FIELD_NAME.name());

		subjectOutputFieldName = "subject";
		predicateOutputFieldName = "predicate";
		objectOutputFieldName = "object";
		datatypeOutputFieldName = "datatype";
		langTagOutputFieldName = "langtag";
		keepInputFields = false;
	}

	/**
	 * It describes what each output row is going to look like
	 */
	@Override
	public void getFields(RowMetaInterface inputRowMeta, String name, RowMetaInterface[] info, StepMeta nextStep,
			VariableSpace space) throws KettleStepException {

		ValueMetaInterface field = null;
		boolean sbjOutFieldSpecified = (subjectOutputFieldName != null) && !("".equals(subjectOutputFieldName));
		ValueMetaInterface inUriField = inputRowMeta.searchValueMeta(this.subjectUriFieldName);

		if (!keepInputFields) {
			inputRowMeta.clear();

			if (sbjOutFieldSpecified) {// [s p o] = S3
										// add out sbj
				field = new ValueMetaString(subjectOutputFieldName);
				field.setOrigin(name);
				inputRowMeta.addValueMeta(field);
			} else { // [uri p o] = S4
						// add in uri
				inputRowMeta.addValueMeta(inUriField);
			}
		} else {
			if (sbjOutFieldSpecified && !subjectOutputFieldName.equals(subjectUriFieldName)) {
				// add out sbj == [uri A B C ... s p o] = S2
				field = new ValueMetaString(subjectOutputFieldName);
				field.setOrigin(name);
				inputRowMeta.addValueMeta(field);
			}
			// else = [uri A B C ... p o] = S1
		}

		field = new ValueMetaString(predicateOutputFieldName);
		field.setOrigin(name);
		inputRowMeta.addValueMeta(field);

		field = new ValueMetaString(objectOutputFieldName);
		field.setOrigin(name);
		inputRowMeta.addValueMeta(field);

		field = new ValueMetaString(datatypeOutputFieldName);
		field.setOrigin(name);
		inputRowMeta.addValueMeta(field);

		field = new ValueMetaString(langTagOutputFieldName);
		field.setOrigin(name);
		inputRowMeta.addValueMeta(field);
	}

	boolean isThereAdditionalSubjectOutputField() {
		return (subjectOutputFieldName != null) && !("".equals(subjectOutputFieldName))
				&& !subjectOutputFieldName.equals(subjectUriFieldName);
	}

	String getActualSubjectOutputFieldName() {
		if ((subjectOutputFieldName != null) && !("".equals(subjectOutputFieldName))) {
			return subjectOutputFieldName;
		} else
			return subjectUriFieldName;
	}

	// Getters & Setters

	public List<String> getRdfTypeUris() {
		return rdfTypeUris;
	}

	public void setRdfTypeUris(List<String> rdfTypeUris) {
		this.rdfTypeUris = rdfTypeUris;
	}

	public String getSubjectUriFieldName() {
		return subjectUriFieldName;
	}

	public void setSubjectUriFieldName(String subjectUriFieldName) {
		this.subjectUriFieldName = subjectUriFieldName;
	}

	public DataTable<String> getMapTable() {
		return mapTable;
	}

	public String getSubjectOutputFieldName() {
		return subjectOutputFieldName;
	}

	public void setSubjectOutputFieldName(String subjectOutputFieldName) {
		this.subjectOutputFieldName = subjectOutputFieldName;
	}

	public String getPredicateOutputFieldName() {
		return predicateOutputFieldName;
	}

	public void setPredicateOutputFieldName(String predicateOutputFieldName) {
		this.predicateOutputFieldName = predicateOutputFieldName;
	}

	public String getObjectOutputFieldName() {
		return objectOutputFieldName;
	}

	public void setObjectOutputFieldName(String objectOutputFieldName) {
		this.objectOutputFieldName = objectOutputFieldName;
	}

	public boolean isKeepInputFields() {
		return keepInputFields;
	}

	public void setKeepInputFields(boolean keepInputFields) {
		this.keepInputFields = keepInputFields;
	}

	public void setDatatypeOutputFieldName(String datatypeOutputFieldName) {
		this.datatypeOutputFieldName = datatypeOutputFieldName;
	}

	public String getDatatypeOutputFieldName() {
		return datatypeOutputFieldName;
	}

	public void setLangTagOutputFieldName(String langTagOutputFieldName) {
		this.langTagOutputFieldName = langTagOutputFieldName;
	}

	public String getLangTagOutputFieldName() {
		return langTagOutputFieldName;
	}

	public void setMapTable(DataTable<String> mapTable) {
		this.mapTable = mapTable;
	}
}


1		package br.ufrj.ppgi.greco.kettle;
2
3		import java.util.ArrayList;
4		import java.util.List;
5		import java.util.Map;
6
7		import org.pentaho.di.core.CheckResult;
8		import org.pentaho.di.core.CheckResultInterface;
9		import org.pentaho.di.core.Counter;
10		import org.pentaho.di.core.database.DatabaseMeta;
11		import org.pentaho.di.core.exception.KettleException;
12		import org.pentaho.di.core.exception.KettleStepException;
13		import org.pentaho.di.core.exception.KettleXMLException;
14		import org.pentaho.di.core.row.RowMetaInterface;
15		import org.pentaho.di.core.row.ValueMetaInterface;
16		import org.pentaho.di.core.row.value.ValueMetaString;
17		import org.pentaho.di.core.variables.VariableSpace;
18		import org.pentaho.di.core.xml.XMLHandler;
19		import org.pentaho.di.repository.ObjectId;
20		import org.pentaho.di.repository.Repository;
21		import org.pentaho.di.trans.Trans;
22		import org.pentaho.di.trans.TransMeta;
23		import org.pentaho.di.trans.step.BaseStepMeta;
24		import org.pentaho.di.trans.step.StepDataInterface;
25		import org.pentaho.di.trans.step.StepInterface;
26		import org.pentaho.di.trans.step.StepMeta;
27		import org.pentaho.di.trans.step.StepMetaInterface;
28		import org.w3c.dom.Node;
29
30		import br.ufrj.ppgi.greco.kettle.plugin.tools.datatable.DataTable;
31		import br.ufrj.ppgi.greco.kettle.plugin.tools.datatable.DataTableConverter;
32
33		import com.thoughtworks.xstream.XStream;
34		import com.thoughtworks.xstream.io.xml.DomDriver;
35
36		public class DataPropertyMappingStepMeta extends BaseStepMeta implements StepMetaInterface {
37		// Fields for serialization
38		public enum Field {
39		DATA_ROOT_NODE, VERSION,
40
41		// Aba 'Mapeamento'
42		RDF_TYPE_URIS, SUBJECT_URI_FIELD_NAME, MAP_TABLE, MAP_TABLE_PREDICATE_FIELD_NAME, MAP_TABLE_PREDICATE_URI, MAP_TABLE_OBJECT_FIELD_NAME, MAP_TABLE_TYPED_LITERAL, MAP_TABLE_LANGUAGE_TAG, MAP_TABLE_LANGTAG_FIELD_NAME,
43
44		// Aba 'Campos de saida'
45		SUBJECT_OUT_FIELD_NAME, PREDICATE_OUT_FIELD_NAME, OBJECT_OUT_FIELD_NAME, DATATYPE_OUT_FIELD_NAME, LANGTAG_OUT_FIELD_NAME, KEEP_INPUT_FIELDS,
46
47		// Aba 'Sparql Endpoint' - no futuro
48		ENDPOINT_URI, DEFAULT_GRAPH, PREFIX_TABLE, PREFIX_TABLE_PREFIX, PREFIX_TABLE_NAMESPACE
49		}
50
51		// Campos do step
52		private List<String> rdfTypeUris;
53		private String subjectUriFieldName;
54		private DataTable<String> mapTable;
55
56		private String subjectOutputFieldName;
57		private String predicateOutputFieldName;
58		private String objectOutputFieldName;
59		private String datatypeOutputFieldName;
60		private String langTagOutputFieldName;
61		private boolean keepInputFields;
62
63		// private String endpointUri;
64		// private String defaultGraph;
65		// private DataTable<String> prefixes;
66
67		public DataPropertyMappingStepMeta() {
68		setDefault();
69		}
70
71		// TODO Validar todos os campos para dar feedback ao usuario!
72		@Override
73		public void check(List<CheckResultInterface> remarks, TransMeta transMeta, StepMeta stepMeta, RowMetaInterface prev,
74		String[] input, String[] output, RowMetaInterface info) {
75		CheckResultInterface ok = new CheckResult(CheckResult.TYPE_RESULT_OK, "", stepMeta);
76		remarks.add(ok);
77		}
78
79		public StepInterface getStep(StepMeta stepMeta, StepDataInterface stepDataInterface, int copyNr,
80		TransMeta transMeta, Trans trans) {
81		return new DataPropertyMappingStep(stepMeta, stepDataInterface, copyNr, transMeta, trans);
82		}
83
84		public StepDataInterface getStepData() {
85		return new DataPropertyMappingStepData();
86		}
87
88		@Override
89		public String getDialogClassName() {
90		return DataPropertyMappingStepDialog.class.getName();
91		}
92
93		@SuppressWarnings("unchecked")
94		@Override
95		public void loadXML(Node stepDomNode, List<DatabaseMeta> databases, Map<String, Counter> sequenceCounters)
96		throws KettleXMLException {
97		try {
98		XStream xs = new XStream(new DomDriver());
99		xs.alias("DataTable", DataTable.class);
100		xs.registerConverter(new DataTableConverter());
101
102		rdfTypeUris = (List<String>) xs.fromXML(XMLHandler.getTagValue(stepDomNode, Field.RDF_TYPE_URIS.name()));
103		subjectUriFieldName = (String) XMLHandler.getTagValue(stepDomNode, Field.SUBJECT_URI_FIELD_NAME.name());
104		mapTable = (DataTable<String>) xs.fromXML(XMLHandler.getTagValue(stepDomNode, Field.MAP_TABLE.name()));
105		subjectOutputFieldName = (String) XMLHandler.getTagValue(stepDomNode, Field.SUBJECT_OUT_FIELD_NAME.name());
106		predicateOutputFieldName = (String) XMLHandler.getTagValue(stepDomNode, Field.PREDICATE_OUT_FIELD_NAME.name());
107		objectOutputFieldName = (String) XMLHandler.getTagValue(stepDomNode, Field.OBJECT_OUT_FIELD_NAME.name());
108		datatypeOutputFieldName = (String) XMLHandler.getTagValue(stepDomNode, Field.DATATYPE_OUT_FIELD_NAME.name());
109		langTagOutputFieldName = (String) XMLHandler.getTagValue(stepDomNode, Field.LANGTAG_OUT_FIELD_NAME.name());
110		keepInputFields = Boolean.valueOf(XMLHandler.getTagValue(stepDomNode, Field.KEEP_INPUT_FIELDS.name()));
111
112		} catch (Throwable e) {
113		e.printStackTrace();
114		}
115		}
116
117		@Override
118		public String getXML() throws KettleException {
119		XStream xs = new XStream(new DomDriver());
120		xs.alias("DataTable", DataTable.class);
121		xs.registerConverter(new DataTableConverter());
122
123		StringBuilder xml = new StringBuilder();
124
125		xml.append(XMLHandler.addTagValue(Field.RDF_TYPE_URIS.name(), xs.toXML(rdfTypeUris)));
126		xml.append(XMLHandler.addTagValue(Field.SUBJECT_URI_FIELD_NAME.name(), subjectUriFieldName));
127		xml.append(XMLHandler.addTagValue(Field.MAP_TABLE.name(), xs.toXML(mapTable)));
128		xml.append(XMLHandler.addTagValue(Field.SUBJECT_OUT_FIELD_NAME.name(), subjectOutputFieldName));
129		xml.append(XMLHandler.addTagValue(Field.PREDICATE_OUT_FIELD_NAME.name(), predicateOutputFieldName));
130		xml.append(XMLHandler.addTagValue(Field.OBJECT_OUT_FIELD_NAME.name(), objectOutputFieldName));
131		xml.append(XMLHandler.addTagValue(Field.DATATYPE_OUT_FIELD_NAME.name(), datatypeOutputFieldName));
132		xml.append(XMLHandler.addTagValue(Field.LANGTAG_OUT_FIELD_NAME.name(), langTagOutputFieldName));
133		xml.append(XMLHandler.addTagValue(Field.KEEP_INPUT_FIELDS.name(), keepInputFields));
134
135		return xml.toString();
136		}
137
138		@Override
139		public void readRep(Repository repository, ObjectId stepIdInRepository, List<DatabaseMeta> databases,
140		Map<String, Counter> sequenceCounters) throws KettleException {
141		int version = (int) repository.getStepAttributeInteger(stepIdInRepository, Field.VERSION.name());
142
143		switch (version) {
144		case 3:
145		langTagOutputFieldName = repository.getStepAttributeString(stepIdInRepository,
146		Field.LANGTAG_OUT_FIELD_NAME.name());
147		case 2:
148		datatypeOutputFieldName = repository.getStepAttributeString(stepIdInRepository,
149		Field.DATATYPE_OUT_FIELD_NAME.name());
150		case 1:
151		int nrRdfTypeUris = (int) repository.countNrStepAttributes(stepIdInRepository, Field.RDF_TYPE_URIS.name());
152		rdfTypeUris = new ArrayList<String>();
153		for (int i = 0; i < nrRdfTypeUris; i++) {
154		String item = repository.getStepAttributeString(stepIdInRepository, i, Field.RDF_TYPE_URIS.name());
155		rdfTypeUris.add(item);
156		}
157		subjectUriFieldName = repository.getStepAttributeString(stepIdInRepository,
158		Field.SUBJECT_URI_FIELD_NAME.name());
159		int nrLines = (int) repository.getStepAttributeInteger(stepIdInRepository, "nr_lines");
160		mapTable = new DataTable<String>(Field.MAP_TABLE.name(), Field.MAP_TABLE_PREDICATE_FIELD_NAME.name(),
161		Field.MAP_TABLE_PREDICATE_URI.name(), Field.MAP_TABLE_OBJECT_FIELD_NAME.name(),
162		Field.MAP_TABLE_TYPED_LITERAL.name(), Field.MAP_TABLE_LANGUAGE_TAG.name(),
163		Field.MAP_TABLE_LANGTAG_FIELD_NAME.name());
164		String[] fields = mapTable.getHeader().toArray(new String[0]);
165		/*
166		* { Field.MAP_TABLE_PREDICATE_FIELD_NAME.name(),
167		* Field.MAP_TABLE_PREDICATE_URI.name(),
168		* Field.MAP_TABLE_OBJECT_FIELD_NAME.name(),
169		* Field.MAP_TABLE_TYPED_LITERAL.name(),
170		* Field.MAP_TABLE_LANGUAGE_TAG.name(),
171		* Field.MAP_TABLE_LANGTAG_FIELD_NAME.name() };
172		*/
173	View Code Duplication	for (int i = 0; i < nrLines; i++) {
		0 ignored issues – show Duplication introduced 2018-10-21 01:00 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
174		int nrfields = fields.length;
175		String[] line = new String[nrfields];
176
177		for (int f = 0; f < nrfields; f++) {
178		line[f] = repository.getStepAttributeString(stepIdInRepository, i, fields[f]);
179		}
180		mapTable.add(line);
181		}
182		subjectOutputFieldName = repository.getStepAttributeString(stepIdInRepository,
183		Field.SUBJECT_OUT_FIELD_NAME.name());
184		predicateOutputFieldName = repository.getStepAttributeString(stepIdInRepository,
185		Field.PREDICATE_OUT_FIELD_NAME.name());
186		objectOutputFieldName = repository.getStepAttributeString(stepIdInRepository,
187		Field.OBJECT_OUT_FIELD_NAME.name());
188		keepInputFields = repository.getStepAttributeBoolean(stepIdInRepository, Field.KEEP_INPUT_FIELDS.name());
189		break;
190		default:
191		setDefault();
192		}
193		}
194
195	View Code Duplication	@Override
		0 ignored issues – show Duplication introduced 2018-10-21 01:00 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
196		public void saveRep(Repository repository, ObjectId idOfTransformation, ObjectId idOfStep) throws KettleException {
197		try {
198		repository.saveStepAttribute(idOfTransformation, idOfStep, Field.VERSION.name(), 3);
199		repository.saveStepAttribute(idOfTransformation, idOfStep, Field.LANGTAG_OUT_FIELD_NAME.name(),
200		langTagOutputFieldName);
201		repository.saveStepAttribute(idOfTransformation, idOfStep, Field.DATATYPE_OUT_FIELD_NAME.name(),
202		datatypeOutputFieldName);
203		repository.saveStepAttribute(idOfTransformation, idOfStep, Field.SUBJECT_URI_FIELD_NAME.name(),
204		subjectUriFieldName);
205		repository.saveStepAttribute(idOfTransformation, idOfStep, Field.SUBJECT_OUT_FIELD_NAME.name(),
206		subjectOutputFieldName);
207		repository.saveStepAttribute(idOfTransformation, idOfStep, Field.PREDICATE_OUT_FIELD_NAME.name(),
208		predicateOutputFieldName);
209		repository.saveStepAttribute(idOfTransformation, idOfStep, Field.OBJECT_OUT_FIELD_NAME.name(),
210		objectOutputFieldName);
211		repository.saveStepAttribute(idOfTransformation, idOfStep, Field.KEEP_INPUT_FIELDS.name(), keepInputFields);
212
213		// Lista de RDF Type URIs
214		for (int i = 0; i < rdfTypeUris.size(); i++) {
215		repository.saveStepAttribute(idOfTransformation, idOfStep, i, Field.RDF_TYPE_URIS.name(),
216		rdfTypeUris.get(i));
217		}
218
219		// Map Table
220		int linhas = (int) mapTable.size();
221		int colunas = mapTable.getHeader().size();
222		repository.saveStepAttribute(idOfTransformation, idOfStep, "nr_lines", linhas);
223		for (int i = 0; i < linhas; i++) {
224		for (int f = 0; f < colunas; f++) {
225		repository.saveStepAttribute(idOfTransformation, idOfStep, i, mapTable.getHeader().get(f),
226		mapTable.getValue(i, f));
227		}
228		}
229		} catch (Exception e) {
230		throw new KettleException("Unable to save step information to the repository for id_step=" + idOfStep, e);
231		}
232		}
233
234		public void setDefault() {
235		rdfTypeUris = new ArrayList<String>();
236		subjectUriFieldName = "";
237		mapTable = new DataTable<String>(Field.MAP_TABLE.name(), Field.MAP_TABLE_PREDICATE_FIELD_NAME.name(),
238		Field.MAP_TABLE_PREDICATE_URI.name(), Field.MAP_TABLE_OBJECT_FIELD_NAME.name(),
239		Field.MAP_TABLE_TYPED_LITERAL.name(), Field.MAP_TABLE_LANGUAGE_TAG.name(),
240		Field.MAP_TABLE_LANGTAG_FIELD_NAME.name());
241
242		subjectOutputFieldName = "subject";
243		predicateOutputFieldName = "predicate";
244		objectOutputFieldName = "object";
245		datatypeOutputFieldName = "datatype";
246		langTagOutputFieldName = "langtag";
247		keepInputFields = false;
248		}
249
250		/**
251		* It describes what each output row is going to look like
252		*/
253		@Override
254		public void getFields(RowMetaInterface inputRowMeta, String name, RowMetaInterface[] info, StepMeta nextStep,
255		VariableSpace space) throws KettleStepException {
256
257		ValueMetaInterface field = null;
258		boolean sbjOutFieldSpecified = (subjectOutputFieldName != null) && !("".equals(subjectOutputFieldName));
259		ValueMetaInterface inUriField = inputRowMeta.searchValueMeta(this.subjectUriFieldName);
260
261		if (!keepInputFields) {
262		inputRowMeta.clear();
263
264		if (sbjOutFieldSpecified) {// [s p o] = S3
265		// add out sbj
266		field = new ValueMetaString(subjectOutputFieldName);
267		field.setOrigin(name);
268		inputRowMeta.addValueMeta(field);
269		} else { // [uri p o] = S4
270		// add in uri
271		inputRowMeta.addValueMeta(inUriField);
272		}
273		} else {
274		if (sbjOutFieldSpecified && !subjectOutputFieldName.equals(subjectUriFieldName)) {
275		// add out sbj == [uri A B C ... s p o] = S2
276		field = new ValueMetaString(subjectOutputFieldName);
277		field.setOrigin(name);
278		inputRowMeta.addValueMeta(field);
279		}
280		// else = [uri A B C ... p o] = S1
281		}
282
283		field = new ValueMetaString(predicateOutputFieldName);
284		field.setOrigin(name);
285		inputRowMeta.addValueMeta(field);
286
287		field = new ValueMetaString(objectOutputFieldName);
288		field.setOrigin(name);
289		inputRowMeta.addValueMeta(field);
290
291		field = new ValueMetaString(datatypeOutputFieldName);
292		field.setOrigin(name);
293		inputRowMeta.addValueMeta(field);
294
295		field = new ValueMetaString(langTagOutputFieldName);
296		field.setOrigin(name);
297		inputRowMeta.addValueMeta(field);
298		}
299
300		boolean isThereAdditionalSubjectOutputField() {
301		return (subjectOutputFieldName != null) && !("".equals(subjectOutputFieldName))
302		&& !subjectOutputFieldName.equals(subjectUriFieldName);
303		}
304
305		String getActualSubjectOutputFieldName() {
306		if ((subjectOutputFieldName != null) && !("".equals(subjectOutputFieldName))) {
307		return subjectOutputFieldName;
308		} else
309		return subjectUriFieldName;
310		}
311
312		// Getters & Setters
313
314		public List<String> getRdfTypeUris() {
315		return rdfTypeUris;
316		}
317
318		public void setRdfTypeUris(List<String> rdfTypeUris) {
319		this.rdfTypeUris = rdfTypeUris;
320		}
321
322		public String getSubjectUriFieldName() {
323		return subjectUriFieldName;
324		}
325
326		public void setSubjectUriFieldName(String subjectUriFieldName) {
327		this.subjectUriFieldName = subjectUriFieldName;
328		}
329
330		public DataTable<String> getMapTable() {
331		return mapTable;
332		}
333
334		public String getSubjectOutputFieldName() {
335		return subjectOutputFieldName;
336		}
337
338		public void setSubjectOutputFieldName(String subjectOutputFieldName) {
339		this.subjectOutputFieldName = subjectOutputFieldName;
340		}
341
342		public String getPredicateOutputFieldName() {
343		return predicateOutputFieldName;
344		}
345
346		public void setPredicateOutputFieldName(String predicateOutputFieldName) {
347		this.predicateOutputFieldName = predicateOutputFieldName;
348		}
349
350		public String getObjectOutputFieldName() {
351		return objectOutputFieldName;
352		}
353
354		public void setObjectOutputFieldName(String objectOutputFieldName) {
355		this.objectOutputFieldName = objectOutputFieldName;
356		}
357
358		public boolean isKeepInputFields() {
359		return keepInputFields;
360		}
361
362		public void setKeepInputFields(boolean keepInputFields) {
363		this.keepInputFields = keepInputFields;
364		}
365
366		public void setDatatypeOutputFieldName(String datatypeOutputFieldName) {
367		this.datatypeOutputFieldName = datatypeOutputFieldName;
368		}
369
370		public String getDatatypeOutputFieldName() {
371		return datatypeOutputFieldName;
372		}
373
374		public void setLangTagOutputFieldName(String langTagOutputFieldName) {
375		this.langTagOutputFieldName = langTagOutputFieldName;
376		}
377
378		public String getLangTagOutputFieldName() {
379		return langTagOutputFieldName;
380		}
381
382		public void setMapTable(DataTable<String> mapTable) {
383		this.mapTable = mapTable;
384		}
385		}
386

johncurcio / ETL4LODPlus

isThereAdditionalSubjectOutputField() A last analyzed 2019-10-13 02:26 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

isThereAdditionalSubjectOutputField() A
last analyzed 2019-10-13 02:26 UTC