/*******************************************************************************
* Copyright (c) 2014 Hussein Mhanna
*
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Hussein Mhanna - initial API and implementation
******************************************************************************/
package org.eclipse.rmf.reqif10.csv.importer.utils;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.eclipse.core.resources.IFile;
import org.eclipse.emf.common.command.Command;
import org.eclipse.emf.common.command.CompoundCommand;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EAttribute;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.emf.edit.command.AddCommand;
import org.eclipse.emf.edit.command.CommandParameter;
import org.eclipse.emf.edit.command.CreateChildCommand;
import org.eclipse.emf.edit.domain.AdapterFactoryEditingDomain;
import org.eclipse.emf.edit.domain.EditingDomain;
import org.eclipse.emf.edit.provider.ComposedAdapterFactory;
import org.eclipse.rmf.reqif10.AttributeDefinition;
import org.eclipse.rmf.reqif10.AttributeDefinitionBoolean;
import org.eclipse.rmf.reqif10.AttributeDefinitionDate;
import org.eclipse.rmf.reqif10.AttributeDefinitionEnumeration;
import org.eclipse.rmf.reqif10.AttributeDefinitionInteger;
import org.eclipse.rmf.reqif10.AttributeDefinitionReal;
import org.eclipse.rmf.reqif10.AttributeDefinitionString;
import org.eclipse.rmf.reqif10.AttributeDefinitionXHTML;
import org.eclipse.rmf.reqif10.AttributeValue;
import org.eclipse.rmf.reqif10.AttributeValueEnumeration;
import org.eclipse.rmf.reqif10.AttributeValueXHTML;
import org.eclipse.rmf.reqif10.DatatypeDefinition;
import org.eclipse.rmf.reqif10.DatatypeDefinitionBoolean;
import org.eclipse.rmf.reqif10.DatatypeDefinitionDate;
import org.eclipse.rmf.reqif10.DatatypeDefinitionEnumeration;
import org.eclipse.rmf.reqif10.DatatypeDefinitionInteger;
import org.eclipse.rmf.reqif10.DatatypeDefinitionReal;
import org.eclipse.rmf.reqif10.DatatypeDefinitionString;
import org.eclipse.rmf.reqif10.DatatypeDefinitionXHTML;
import org.eclipse.rmf.reqif10.EnumValue;
import org.eclipse.rmf.reqif10.ReqIF;
import org.eclipse.rmf.reqif10.ReqIF10Factory;
import org.eclipse.rmf.reqif10.ReqIF10Package;
import org.eclipse.rmf.reqif10.SpecHierarchy;
import org.eclipse.rmf.reqif10.SpecObject;
import org.eclipse.rmf.reqif10.SpecObjectType;
import org.eclipse.rmf.reqif10.SpecType;
import org.eclipse.rmf.reqif10.Specification;
import org.eclipse.rmf.reqif10.XhtmlContent;
import org.eclipse.rmf.reqif10.common.util.ProrXhtmlSimplifiedHelper;
import org.eclipse.rmf.reqif10.common.util.ReqIF10Util;
import org.eclipse.rmf.reqif10.csv.importer.mapping.DataType;
import org.eclipse.rmf.reqif10.csv.importer.mapping.MappingItem;
import org.eclipse.rmf.reqif10.csv.importer.mapping.MappingLibrary;
import org.eclipse.rmf.reqif10.xhtml.XhtmlDivType;
import au.com.bytecode.opencsv.CSVReader;
public class Importer {
private static final ReqIF10Factory FACTORY = ReqIF10Factory.eINSTANCE;
private EditingDomain editingDomain;
private String path;
private MappingLibrary library;
private ReqIF reqIf;
private char separator;
private boolean header;
private CompoundCommand compoundCommand;
private Map<String, AttributeDefinition> attributeDefinitionMap;
public Importer(EditingDomain editingDomain, String path,
MappingLibrary library, ReqIF reqIf, char separator, boolean header) {
super();
this.editingDomain = editingDomain;
this.path = path;
this.library = library;
this.reqIf = reqIf;
this.separator = separator;
this.header = header;
attributeDefinitionMap = new HashMap<String, AttributeDefinition>();
}
public static void importReq(EditingDomain editingDomain, IFile file,
String path, MappingLibrary library, char separator, boolean header)
throws IOException {
boolean needDispose = false;
if (editingDomain == null) {
URI uri = URI.createPlatformResourceURI(file.getFullPath()
.toOSString(), true);
editingDomain = Utils.createReqIFEditingDomain();
editingDomain.getResourceSet().getResource(uri, true);
needDispose = true;
}
ReqIF reqIf = (ReqIF) editingDomain.getResourceSet().getResources()
.get(0).getContents().get(0);
Importer importer = new Importer(editingDomain, path, library, reqIf,
separator, header);
importer.doImportReq();
if (needDispose) {
ComposedAdapterFactory adapterFactory = (ComposedAdapterFactory) ((AdapterFactoryEditingDomain) editingDomain)
.getAdapterFactory();
adapterFactory.dispose();
EList<Resource> resources = editingDomain.getResourceSet()
.getResources();
final Map<Object, Object> saveOptions = new HashMap<Object, Object>();
saveOptions.put(Resource.OPTION_SAVE_ONLY_IF_CHANGED,
Resource.OPTION_SAVE_ONLY_IF_CHANGED_MEMORY_BUFFER);
for (Resource resource : resources) {
resource.save(saveOptions);
resource.unload();
resource.getContents().clear();
}
}
}
public void doImportReq() throws IOException {
CSVReader reader = new CSVReader(new FileReader(path), separator);
Map<Short, String> map = null;
if (header) {
String[] headerNames = reader.readNext();
map = buildMappingMap(library, Arrays.asList(headerNames));
} else {
map = buildMappingMap(library);
}
compoundCommand = new CompoundCommand();
importReq(reader, map, library.getItems());
editingDomain.getCommandStack().execute(compoundCommand);
compoundCommand = null;
attributeDefinitionMap.clear();
}
protected void importReq(CSVReader reader, Map<Short, String> map,
List<MappingItem> mappingItems) throws IOException {
Specification specification = reqIf.getCoreContent()
.getSpecifications().get(0);
SpecObjectType specObjectType = getSpecObjectType(mappingItems,
getSpecTypeName());
String[] nextLine;
while ((nextLine = reader.readNext()) != null) {
Command command = CreateChildCommand.create(editingDomain,
specification, new CommandParameter(specification,
ReqIF10Package.Literals.SPECIFICATION__CHILDREN,
specObjectType), Collections
.singleton(specification));
compoundCommand.appendAndExecute(command);
Collection<?> result = command.getResult();
for (Object object : result) {
if (object instanceof SpecHierarchy) {
SpecObject specObject = ((SpecHierarchy) object)
.getObject();
createAttributeValues(specObject);
for (int i = 0; i < nextLine.length; i++) {
String attributeName = map.get((short) i);
String attributeStringValue = nextLine[i];
if (attributeName != null) {
EAttribute attribute = getSpecObjectAttribute(attributeName);
if (attribute != null) {
specObject.eSet(attribute, EcoreUtil
.createFromString(
attribute.getEAttributeType(),
attributeStringValue));
} else {
AttributeDefinition attributeDefinition = attributeDefinitionMap
.get(attributeName);
AttributeValue attributeValue = ReqIF10Util
.getAttributeValue(specObject,
attributeDefinition);
if (attributeValue != null) {
if (attributeValue instanceof AttributeValueEnumeration) {
EnumValue enumValue = getEnumValue(
(AttributeDefinitionEnumeration) attributeDefinition,
attributeStringValue);
ReqIF10Util.setTheValue(attributeValue,
Collections
.singleton(enumValue));
} else if (attributeValue instanceof AttributeValueXHTML) {
AttributeValueXHTML attributeValueXHTML = (AttributeValueXHTML) attributeValue;
// The formatted text is edited
XhtmlDivType div = ProrXhtmlSimplifiedHelper
.stringToSimplifiedXhtml(attributeStringValue);
XhtmlContent origTheValue = attributeValueXHTML
.getTheValue();
if (origTheValue == null) {
origTheValue = ReqIF10Factory.eINSTANCE
.createXhtmlContent();
attributeValueXHTML
.setTheValue(origTheValue);
}
if (!attributeValueXHTML.isSimplified()) {
boolean formattedAttribute = ProrXhtmlSimplifiedHelper
.isFormattedAttribute(origTheValue);
if (formattedAttribute) {
attributeValueXHTML
.setSimplified(true);
}
}
origTheValue.setXhtml(div);
} else {
EAttribute eAttribute = (EAttribute) ReqIF10Util
.getTheValueFeature(attributeValue);
ReqIF10Util
.setTheValue(
attributeValue,
EcoreUtil
.createFromString(
eAttribute
.getEAttributeType(),
attributeStringValue));
}
}
}
}
}
}
}
}
reader.close();
}
private void createAttributeValues(SpecObject specObject) {
EList<AttributeDefinition> attributeDefinitions = specObject.getType()
.getSpecAttributes();
for (AttributeDefinition attributeDefinition : attributeDefinitions) {
specObject.getValues().add(
ReqIF10Util.createAttributeValue(attributeDefinition));
}
}
private EnumValue getEnumValue(
AttributeDefinitionEnumeration attributeDefinition,
String attributeStringValue) {
EList<EnumValue> values = attributeDefinition.getType()
.getSpecifiedValues();
for (EnumValue enumValue : values) {
if ((enumValue.getLongName() != null)
&& (enumValue.getLongName().equals(attributeStringValue))) {
return enumValue;
}
}
// Create the attribute value and return it
EnumValue enumValue = FACTORY.createEnumValue();
enumValue.setLongName(attributeStringValue);
values.add(enumValue);
return enumValue;
}
protected SpecObjectType getSpecObjectType(List<MappingItem> mappingItems,
String specTypeName) {
EList<SpecType> specTypes = reqIf.getCoreContent().getSpecTypes();
for (SpecType specType : specTypes) {
if (specType instanceof SpecObjectType) {
SpecObjectType specObjectType = (SpecObjectType) specType;
if (containsAttributeDefinitions(specObjectType, mappingItems,
specTypeName)) {
fillAttributeDefinitionMap(specObjectType);
return specObjectType;
}
}
}
return createSpecObjectType(mappingItems, specTypeName);
}
private void fillAttributeDefinitionMap(SpecObjectType specObjectType) {
EList<AttributeDefinition> attributeDefinitions = specObjectType
.getSpecAttributes();
for (AttributeDefinition attributeDefinition : attributeDefinitions) {
attributeDefinitionMap.put(attributeDefinition.getLongName(),
attributeDefinition);
}
}
private boolean containsAttributeDefinitions(SpecObjectType specObjectType,
List<MappingItem> mappingItems, String specTypeName) {
if ((specObjectType.getLongName() == null)
|| (false == specObjectType.getLongName().equals(specTypeName))) {
return false;
}
if (mappingItems.size() != specObjectType.getSpecAttributes().size()) {
return false;
}
for (MappingItem mappingItem : mappingItems) {
if (false == containsAttributeDefinition(specObjectType,
mappingItem)) {
return false;
}
}
return true;
}
private boolean containsAttributeDefinition(SpecObjectType specObjectType,
MappingItem item) {
boolean found = false;
EList<AttributeDefinition> attributeDefinitions = specObjectType
.getSpecAttributes();
for (AttributeDefinition attributeDefinition : attributeDefinitions) {
if ((attributeDefinition.getLongName() != null)
&& (attributeDefinition.getLongName().equals(item
.getAttributeName()))) {
switch (item.getDataType()) {
case BOOLEAN:
found = attributeDefinition instanceof AttributeDefinitionBoolean;
break;
case INTEGER:
found = attributeDefinition instanceof AttributeDefinitionInteger;
break;
case REAL:
found = attributeDefinition instanceof AttributeDefinitionReal;
break;
case DATE:
found = attributeDefinition instanceof AttributeDefinitionDate;
break;
case XHTML:
found = attributeDefinition instanceof AttributeDefinitionXHTML;
break;
case ENUMERATION:
found = attributeDefinition instanceof AttributeDefinitionEnumeration;
break;
case STRING:
default:
found = attributeDefinition instanceof AttributeDefinitionString;
break;
}
if (found) {
break;
}
}
}
return found;
}
protected SpecObjectType createSpecObjectType(
List<MappingItem> mappingItems, String specTypeName) {
SpecObjectType specObjectType = FACTORY.createSpecObjectType();
specObjectType.setLongName(specTypeName);
for (MappingItem mappingItem : mappingItems) {
String attributeName = mappingItem.getAttributeName();
if (getSpecObjectAttribute(attributeName) == null) {
DatatypeDefinition datatypeDefinition = createDatatypeDefinition(
mappingItem.getDataType(), attributeName);
Command command = AddCommand.create(editingDomain,
reqIf.getCoreContent(),
ReqIF10Package.Literals.REQ_IF_CONTENT__DATATYPES,
Collections.singleton(datatypeDefinition));
compoundCommand.appendAndExecute(command);
AttributeDefinition attributeDefinition = createAttributeDefinition(
datatypeDefinition, attributeName);
attributeDefinition.setLongName(attributeName);
specObjectType.getSpecAttributes().add(attributeDefinition);
}
}
Command specTypecommand = AddCommand.create(editingDomain,
reqIf.getCoreContent(),
ReqIF10Package.Literals.REQ_IF_CONTENT__SPEC_TYPES,
Collections.singleton(specObjectType));
compoundCommand.appendAndExecute(specTypecommand);
fillAttributeDefinitionMap(specObjectType);
return specObjectType;
}
protected AttributeDefinition createAttributeDefinition(
DatatypeDefinition datatypeDefinition, String name) {
AttributeDefinition attributeDefinition = null;
if (datatypeDefinition instanceof DatatypeDefinitionBoolean) {
attributeDefinition = FACTORY.createAttributeDefinitionBoolean();
((AttributeDefinitionBoolean) attributeDefinition)
.setType((DatatypeDefinitionBoolean) datatypeDefinition);
} else if (datatypeDefinition instanceof DatatypeDefinitionInteger) {
attributeDefinition = FACTORY.createAttributeDefinitionInteger();
((AttributeDefinitionInteger) attributeDefinition)
.setType((DatatypeDefinitionInteger) datatypeDefinition);
} else if (datatypeDefinition instanceof DatatypeDefinitionReal) {
attributeDefinition = FACTORY.createAttributeDefinitionReal();
((AttributeDefinitionReal) attributeDefinition)
.setType((DatatypeDefinitionReal) datatypeDefinition);
} else if (datatypeDefinition instanceof DatatypeDefinitionDate) {
attributeDefinition = FACTORY.createAttributeDefinitionDate();
((AttributeDefinitionDate) attributeDefinition)
.setType((DatatypeDefinitionDate) datatypeDefinition);
} else if (datatypeDefinition instanceof DatatypeDefinitionXHTML) {
attributeDefinition = FACTORY.createAttributeDefinitionXHTML();
((AttributeDefinitionXHTML) attributeDefinition)
.setType((DatatypeDefinitionXHTML) datatypeDefinition);
} else if (datatypeDefinition instanceof DatatypeDefinitionEnumeration) {
attributeDefinition = FACTORY
.createAttributeDefinitionEnumeration();
((AttributeDefinitionEnumeration) attributeDefinition)
.setType((DatatypeDefinitionEnumeration) datatypeDefinition);
} else {
attributeDefinition = FACTORY.createAttributeDefinitionString();
((AttributeDefinitionString) attributeDefinition)
.setType((DatatypeDefinitionString) datatypeDefinition);
}
attributeDefinition.setLongName(name);
return attributeDefinition;
}
protected DatatypeDefinition createDatatypeDefinition(DataType dataType,
String name) {
DatatypeDefinition dataTypeDefinition = null;
switch (dataType) {
case BOOLEAN:
dataTypeDefinition = FACTORY.createDatatypeDefinitionBoolean();
break;
case INTEGER:
dataTypeDefinition = FACTORY.createDatatypeDefinitionInteger();
break;
case REAL:
dataTypeDefinition = FACTORY.createDatatypeDefinitionReal();
break;
case DATE:
dataTypeDefinition = FACTORY.createDatatypeDefinitionDate();
break;
case XHTML:
dataTypeDefinition = FACTORY.createDatatypeDefinitionXHTML();
break;
case ENUMERATION:
dataTypeDefinition = FACTORY.createDatatypeDefinitionEnumeration();
break;
case STRING:
default:
dataTypeDefinition = FACTORY.createDatatypeDefinitionString();
break;
}
dataTypeDefinition.setLongName(name);
return dataTypeDefinition;
}
protected EAttribute getSpecObjectAttribute(String attributeName) {
EStructuralFeature feature = ReqIF10Package.Literals.SPEC_OBJECT
.getEStructuralFeature(attributeName);
if (feature instanceof EAttribute) {
return (EAttribute) feature;
}
return null;
}
protected Map<Short, String> buildMappingMap(MappingLibrary library) {
List<MappingItem> items = library.getItems();
Map<Short, String> map = new HashMap<Short, String>(items.size());
for (MappingItem columnIndexMappingItem : items) {
map.put(Short.valueOf(columnIndexMappingItem.getColumnId()),
columnIndexMappingItem.getAttributeName());
}
return map;
}
protected Map<Short, String> buildMappingMap(MappingLibrary library,
List<String> columnNames) {
List<MappingItem> items = library.getItems();
Map<Short, String> map = new HashMap<Short, String>(items.size());
for (MappingItem columnNameMappingItem : items) {
String columnName = columnNameMappingItem.getColumnId();
short columnIndex = (short) columnNames.indexOf(columnName);
if (columnIndex != -1) {
map.put(columnIndex, columnNameMappingItem.getAttributeName());
}
}
return map;
}
protected String getSpecTypeName() {
return path.substring(path.lastIndexOf(File.separator) + 1,
path.lastIndexOf('.'));
}
}