protected void updateConnectionItem() throws CoreException {
IWorkspace workspace = ResourcesPlugin.getWorkspace();
final IProxyRepositoryFactory factory = ProxyRepositoryFactory.getInstance();
IWorkspaceRunnable operation =
new IWorkspaceRunnable() {
public void run(IProgressMonitor monitor) throws CoreException {
try {
factory.save(connectionItem);
closeLockStrategy();
} catch (PersistenceException e) {
throw new CoreException(
new Status(
IStatus.ERROR,
"org.talend.metadata.management.ui",
"Error when save the connection",
e));
}
}
};
ISchedulingRule schedulingRule = workspace.getRoot();
// the update the project files need to be done in the workspace runnable to avoid all
// notification of changes before the end of the modifications.
workspace.run(operation, schedulingRule, IWorkspace.AVOID_UPDATE, new NullProgressMonitor());
}
/*
* (non-Javadoc)
*
* @see org.talend.commons.ui.swt.actions.ITreeContextualAction#init(org.eclipse.jface.viewers.TreeViewer,
* org.eclipse.jface.viewers.IStructuredSelection)
*/
@Override
public void init(TreeViewer viewer, IStructuredSelection selection) {
boolean canWork = !selection.isEmpty() && selection.size() == 1;
IProxyRepositoryFactory factory = ProxyRepositoryFactory.getInstance();
if (factory.isUserReadOnlyOnCurrentProject()) {
canWork = false;
}
if (canWork) {
Object o = selection.getFirstElement();
RepositoryNode node = (RepositoryNode) o;
switch (node.getType()) {
case SIMPLE_FOLDER:
case SYSTEM_FOLDER:
ERepositoryObjectType nodeType =
(ERepositoryObjectType) node.getProperties(EProperties.CONTENT_TYPE);
if (nodeType != ERepositoryObjectType.PIG_UDF) {
canWork = false;
}
if (node.getObject() != null && node.getObject().isDeleted()) {
canWork = false;
}
break;
default:
canWork = false;
}
if (canWork && !ProjectManager.getInstance().isInCurrentMainProject(node)) {
canWork = false;
}
}
setEnabled(canWork);
}
/**
* create jrxml file.
*
* @param path
* @param label
* @param initFile
* @param extendtion
* @return
*/
public TDQJrxmlItem createJrxml(IPath path, String label, File initFile, String extendtion) {
Property property = PropertiesFactory.eINSTANCE.createProperty();
property.setVersion(VersionUtils.DEFAULT_VERSION);
property.setStatusCode(PluginConstant.EMPTY_STRING);
property.setLabel(label);
TDQJrxmlItem routineItem =
org.talend.dataquality.properties.PropertiesFactory.eINSTANCE.createTDQJrxmlItem();
routineItem.setProperty(property);
routineItem.setExtension(extendtion);
routineItem.setName(label);
ByteArray byteArray = duplicateByteArray(initFile);
routineItem.setContent(byteArray);
IProxyRepositoryFactory repositoryFactory = ProxyRepositoryFactory.getInstance();
try {
property.setId(repositoryFactory.getNextId());
if (path != null) {
repositoryFactory.createParentFoldersRecursively(
ERepositoryObjectType.getItemType(routineItem), path);
}
repositoryFactory.create(routineItem, path);
} catch (PersistenceException e) {
ExceptionHandler.process(e);
}
return routineItem;
}
/*
* (non-Javadoc)
*
* @see org.talend.repository.ui.actions.ITreeContextualAction#init(org.eclipse.jface.viewers.TreeViewer,
* org.eclipse.jface.viewers.IStructuredSelection)
*/
public void init(TreeViewer viewer, IStructuredSelection selection) {
boolean canWork = !selection.isEmpty() && selection.size() == 1;
if (canWork) {
Object o = selection.getFirstElement();
RepositoryNode node = (RepositoryNode) o;
if (CamelEditorUtil.hasEditorOpened(node)) {
canWork = false;
} else {
switch (node.getType()) {
case REPOSITORY_ELEMENT:
if (node.getObjectType() != CamelRepositoryNodeType.repositoryRoutesType) {
canWork = false;
}
break;
default:
canWork = false;
}
}
if (canWork
&& node.getObject() != null
&& ProxyRepositoryFactory.getInstance().getStatus(node.getObject())
== ERepositoryStatus.LOCK_BY_USER) {
canWork = false;
}
}
setEnabled(canWork);
}
/*
* (non-Javadoc)
*
* @see org.talend.core.ui.ILastVersionChecker#isLastVersion(org.talend.core.model.properties.Item)
*/
public boolean isLastVersion(Item item) {
if (item.getProperty() != null) {
if (item.getProperty().getId() == null) {
return true;
}
try {
List<IRepositoryViewObject> allVersion =
ProxyRepositoryFactory.getInstance().getAllVersion(item.getProperty().getId());
if (allVersion != null && !allVersion.isEmpty()) {
String lastVersion = VersionUtils.DEFAULT_VERSION;
for (IRepositoryViewObject object : allVersion) {
if (VersionUtils.compareTo(object.getVersion(), lastVersion) > 0) {
lastVersion = object.getVersion();
}
}
if (VersionUtils.compareTo(item.getProperty().getVersion(), lastVersion) == 0) {
return true;
}
}
} catch (PersistenceException e) {
ExceptionHandler.process(e);
}
}
return false;
}
/*
* (non-Javadoc)
*
* @see org.talend.repository.ui.actions.ITreeContextualAction#init(org.eclipse.jface.viewers.TreeViewer,
* org.eclipse.jface.viewers.IStructuredSelection)
*/
@Override
public void init(TreeViewer viewer, IStructuredSelection selection) {
super.init(viewer, selection);
boolean canWork = !selection.isEmpty() && selection.size() == 1;
IProxyRepositoryFactory factory = ProxyRepositoryFactory.getInstance();
if (factory.isUserReadOnlyOnCurrentProject()) {
canWork = false;
}
RepositoryNode node = (RepositoryNode) selection.getFirstElement();
if (canWork) {
if (node.getObjectType() != ERepositoryObjectType.ROUTINES
|| !ProjectManager.getInstance().isInCurrentMainProject(node)
|| !isLastVersion(node)) {
canWork = false;
} else {
Item item = node.getObject().getProperty().getItem();
if (item instanceof RoutineItem) {
canWork = !((RoutineItem) item).isBuiltIn();
}
}
}
if (canWork) {
canWork = (factory.getStatus(node.getObject()) != ERepositoryStatus.DELETED);
}
setEnabled(canWork);
}
@Override
public ReturnCode save(final Item item, final boolean careDependency) {
ReturnCode rc = new ReturnCode();
RepositoryWorkUnit<Object> repositoryWorkUnit =
new RepositoryWorkUnit<Object>("save DQRule item") { // $NON-NLS-1$
@Override
protected void run() throws LoginException, PersistenceException {
TDQBusinessRuleItem ruleItem = (TDQBusinessRuleItem) item;
DQRule rule = ruleItem.getDqrule();
// MOD yyi 2012-02-07 TDQ-4621:Update dependencies(connection) when careDependency is
// true.
if (careDependency) {
saveWithDependencies(ruleItem, rule);
} else {
saveWithoutDependencies(ruleItem, rule);
}
}
};
repositoryWorkUnit.setAvoidUnloadResources(true);
ProxyRepositoryFactory.getInstance().executeRepositoryWorkUnit(repositoryWorkUnit);
try {
repositoryWorkUnit.throwPersistenceExceptionIfAny();
} catch (PersistenceException e) {
log.error(e, e);
rc.setOk(Boolean.FALSE);
rc.setMessage(e.getMessage());
}
return rc;
}
/**
* Test method for {@link
* org.talend.dq.writer.AElementPersistance#saveWithDependencies(org.talend.core.model.properties.Item,
* orgomg.cwm.objectmodel.core.ModelElement)} .
*
* @throws PersistenceException
*/
@Test
public void testSaveWithDependenciesAnalysis() throws PersistenceException {
PowerMockito.mockStatic(ProxyRepositoryFactory.class);
ProxyRepositoryFactory mockProxyRepositoryFactory =
PowerMockito.mock(ProxyRepositoryFactory.class);
when(ProxyRepositoryFactory.getInstance()).thenReturn(mockProxyRepositoryFactory);
stub(
method(
ProxyRepositoryFactory.class,
"save",
org.talend.core.model.properties.Item.class,
boolean.class)); // $NON-NLS-1$
PowerMockito.mockStatic(IRepositoryFactory.class);
IRepositoryFactory mockIRepositoryFactory = PowerMockito.mock(IRepositoryFactory.class);
when(mockProxyRepositoryFactory.getRepositoryFactoryFromProvider())
.thenReturn(mockIRepositoryFactory);
PowerMockito.mockStatic(XmiResourceManager.class);
when(mockIRepositoryFactory.getResourceManager()).thenReturn(new XmiResourceManager());
AnalysisWriter createAnalysisWrite = ElementWriterFactory.getInstance().createAnalysisWrite();
Analysis createAnalysis = AnalysisFactory.eINSTANCE.createAnalysis();
AnalysisResult createAnalysisResult = AnalysisFactory.eINSTANCE.createAnalysisResult();
AnalysisContext createAnalysisContext = AnalysisFactory.eINSTANCE.createAnalysisContext();
TDQAnalysisItem analysisItem =
org.talend.dataquality.properties.PropertiesFactory.eINSTANCE.createTDQAnalysisItem();
analysisItem.setAnalysis(createAnalysis);
String anaName = "ana1"; // $NON-NLS-1$
String exceptedFileName = anaName + "_0.1.ana"; // $NON-NLS-1$
createAnalysis.setName(anaName);
createAnalysis.setResults(createAnalysisResult);
createAnalysis.setContext(createAnalysisContext);
ReturnCode create = createAnalysisWrite.saveWithDependencies(analysisItem, createAnalysis);
assertTrue(create.isOk());
Assert.assertEquals(exceptedFileName, analysisItem.getFilename());
String anaName2 = "ana2"; // $NON-NLS-1$
String exceptedFileName2 = anaName2 + "_0.1.ana"; // $NON-NLS-1$
createAnalysis.setName(anaName2);
create = createAnalysisWrite.saveWithDependencies(analysisItem, createAnalysis);
assertTrue(create.isOk());
Assert.assertEquals(exceptedFileName2, analysisItem.getFilename());
}
private boolean refreshNewJob() {
if (alreadyEditedByUser) {
return false;
}
IProxyRepositoryFactory repositoryFactory = ProxyRepositoryFactory.getInstance();
try {
repositoryFactory.save(getProperty(), this.originaleObjectLabel, this.originalVersion);
ExpressionPersistance.getInstance()
.jobNameChanged(originaleObjectLabel, repoObject.getLabel());
ProxyRepositoryFactory.getInstance()
.saveProject(ProjectManager.getInstance().getCurrentProject());
return true;
} catch (PersistenceException e) {
MessageBoxExceptionHandler.process(e);
return false;
}
}
/**
* Test method for {@link
* org.talend.dq.writer.AElementPersistance#saveWithoutDependencies(org.talend.core.model.properties.Item,
* orgomg.cwm.objectmodel.core.ModelElement)} .
*
* @throws PersistenceException
*/
@Test
public void testSaveWithoutDependenciesReport() throws PersistenceException {
PowerMockito.mockStatic(ProxyRepositoryFactory.class);
ProxyRepositoryFactory mockProxyRepositoryFactory =
PowerMockito.mock(ProxyRepositoryFactory.class);
when(ProxyRepositoryFactory.getInstance()).thenReturn(mockProxyRepositoryFactory);
stub(
method(
ProxyRepositoryFactory.class,
"save",
org.talend.core.model.properties.Item.class,
boolean.class)); // $NON-NLS-1$
PowerMockito.mockStatic(IRepositoryFactory.class);
IRepositoryFactory mockIRepositoryFactory = PowerMockito.mock(IRepositoryFactory.class);
when(mockProxyRepositoryFactory.getRepositoryFactoryFromProvider())
.thenReturn(mockIRepositoryFactory);
PowerMockito.mockStatic(XmiResourceManager.class);
when(mockIRepositoryFactory.getResourceManager()).thenReturn(new XmiResourceManager());
ReportWriter createReportWriter = ElementWriterFactory.getInstance().createReportWriter();
TdReport createTdReport = ReportsFactory.eINSTANCE.createTdReport();
TDQReportItem reportItem =
org.talend.dataquality.properties.PropertiesFactory.eINSTANCE.createTDQReportItem();
reportItem.setReport(createTdReport);
String repName = "rep1"; // $NON-NLS-1$
String exceptedFileName = repName + "_0.1.rep"; // $NON-NLS-1$
createTdReport.setName(repName);
ReturnCode create = createReportWriter.saveWithoutDependencies(reportItem, createTdReport);
assertTrue(create.isOk());
Assert.assertEquals(exceptedFileName, reportItem.getFilename());
String repName2 = "rep2"; // $NON-NLS-1$
String exceptedFileName2 = repName2 + "_0.1.rep"; // $NON-NLS-1$
createTdReport.setName(repName2);
create = createReportWriter.saveWithDependencies(reportItem, createTdReport);
assertTrue(create.isOk());
Assert.assertEquals(exceptedFileName2, reportItem.getFilename());
}
/* (non-Javadoc)
* @see org.talend.repository.ui.wizards.CheckLastVersionRepositoryWizard#performFinish()
*/
public boolean performFinish() {
if (this.sapTablePage.isPageComplete()) {
RepositoryUpdateManager.updateSAPFunction(sapTablePage.getFunctionUnit());
ProxyRepositoryFactory localProxyRepositoryFactory = ProxyRepositoryFactory.getInstance();
try {
localProxyRepositoryFactory.save(this.repositoryObject.getProperty().getItem());
RepositoryManager.refresh(ERepositoryObjectType.METADATA_SAP_FUNCTION);
closeLockStrategy();
} catch (PersistenceException persistenceException) {
String message = persistenceException.toString();
new ErrorDialogWidthDetailArea(
getShell(),
"org.talend.repository",
Messages.getString("CommonWizard.persistenceException"),
message);
log.error(Messages.getString("CommonWizard.persistenceException") + "\n" + message);
}
}
return true;
}
@Override
public boolean performFinish() {
boolean formIsPerformed = false;
formIsPerformed = page1.isPageComplete();
if (formIsPerformed) {
IProxyRepositoryFactory factory = ProxyRepositoryFactory.getInstance();
try {
if (creation) {
String nextId = factory.getNextId();
connectionProperty.setId(nextId);
factory.create(connectionItem, salesforceSchemaWizardPage0.getDestinationPath());
} else {
// update
RepositoryUpdateManager.updateFileConnection(connectionItem);
refreshInFinish(salesforceSchemaWizardPage0.isNameModifiedByUser());
updateConnectionItem();
}
ProxyRepositoryFactory.getInstance()
.saveProject(ProjectManager.getInstance().getCurrentProject());
} catch (Exception e) {
String detailError = e.toString();
new ErrorDialogWidthDetailArea(
getShell(),
PID,
Messages.getString("CommonWizard.persistenceException"), // $NON-NLS-1$
detailError);
log.error(
Messages.getString("CommonWizard.persistenceException")
+ "\n"
+ detailError); //$NON-NLS-1$ //$NON-NLS-2$
return false;
}
return true;
} else {
return false;
}
}
private boolean isProjectNameAlreadyUsed(String newProjectName) {
IProxyRepositoryFactory repositoryFactory = ProxyRepositoryFactory.getInstance();
if (projects == null) {
try {
projects = repositoryFactory.readProject();
} catch (Exception e) {
return true;
}
}
for (Project project : projects) {
if (Project.createTechnicalName(newProjectName).compareTo(project.getTechnicalLabel()) == 0) {
return true;
}
}
return false;
}
/*
* (non-Javadoc)
*
* @see
* org.talend.repository.ui.actions.ITreeContextualAction#init(org.eclipse
* .jface.viewers.TreeViewer,
* org.eclipse.jface.viewers.IStructuredSelection)
*/
public void init(TreeViewer viewer, IStructuredSelection selection) {
boolean canWork = !selection.isEmpty() && selection.size() == 1;
IProxyRepositoryFactory factory = ProxyRepositoryFactory.getInstance();
if (factory.isUserReadOnlyOnCurrentProject()) {
canWork = false;
}
if (canWork) {
Object o = selection.getFirstElement();
RepositoryNode node = (RepositoryNode) o;
switch (node.getType()) {
case REPOSITORY_ELEMENT:
if (node.getObjectType() != CamelRepositoryNodeType.repositoryRouteResourceType) {
canWork = false;
} else {
IRepositoryService service = DesignerPlugin.getDefault().getRepositoryService();
IProxyRepositoryFactory repFactory = service.getProxyRepositoryFactory();
if (repFactory.isPotentiallyEditable(node.getObject())) {
this.setText(""); // $NON-NLS-1$
} else {
this.setText(""); // $NON-NLS-1$
}
}
break;
default:
canWork = false;
}
RepositoryNode parent = node.getParent();
if (canWork && parent != null && parent instanceof BinRepositoryNode) {
canWork = false;
}
if (canWork && !ProjectManager.getInstance().isInCurrentMainProject(node)) {
canWork = false;
}
// If the editProcess action canwork is true, then detect that the
// job version is the latest verison or not.
if (canWork) {
canWork = isLastVersion(node);
}
}
setEnabled(canWork);
this.setText("Open another version");
this.setToolTipText("Open another version");
this.setImageDescriptor(
RouteResourceActivator.createImageDesc("icons/open-another-version.png"));
}
// @Override
protected void updateDependencies(ModelElement element) {
// update client dependency
// if IndicatorDefinition have client depencency, add codes here
IndicatorDefinition definition = (IndicatorDefinition) element;
Property property = PropertyHelper.getProperty(definition);
List<IRepositoryViewObject> listIndicatorDependency =
DependenciesHandler.getInstance()
.getIndicatorDependency(new RepositoryViewObject(property));
for (IRepositoryViewObject viewObject : listIndicatorDependency) {
Item item = viewObject.getProperty().getItem();
if (item instanceof TDQAnalysisItem) {
try {
ProxyRepositoryFactory.getInstance().save(item);
} catch (PersistenceException e) {
log.error(e, e);
}
}
}
}
/*
* (non-Javadoc)
*
* @see
* org.talend.repository.ui.actions.metadata.AbstractCreateAction#init(org.talend.repository.model.RepositoryNode)
*/
@Override
protected void init(RepositoryNode node) {
ERepositoryObjectType nodeType =
(ERepositoryObjectType) node.getProperties(EProperties.CONTENT_TYPE);
IProxyRepositoryFactory factory = ProxyRepositoryFactory.getInstance();
if (factory.isUserReadOnlyOnCurrentProject()
|| !ProjectManager.getInstance().isInCurrentMainProject(node)) {
setEnabled(false);
} else {
if (ENodeType.REPOSITORY_ELEMENT.equals(node.getType())) {
if (node.getObject().getRepositoryStatus() == ERepositoryStatus.DELETED
|| node.getObject().getRepositoryStatus() == ERepositoryStatus.LOCK_BY_OTHER) {
setEnabled(false);
return;
}
if ((factory.getStatus(node.getObject()) == ERepositoryStatus.DELETED)
|| (factory.getStatus(node.getObject()) == ERepositoryStatus.LOCK_BY_OTHER)) {
setEnabled(false);
return;
}
if (ERepositoryObjectType.METADATA_CON_TABLE.equals(nodeType)
|| ERepositoryObjectType.METADATA_CON_COLUMN.equals(nodeType)) {
RepositoryNode parent = node.getParent();
if (parent != null
&& HCatalogRepositoryNodeType.HCATALOG.equals(
parent.getProperties(EProperties.CONTENT_TYPE))) {
setText(EDIT_LABEL);
collectSiblingNames(node);
setEnabled(true);
return;
}
} else if (HCatalogRepositoryNodeType.HCATALOG.equals(nodeType)) {
setText(CREATE_LABEL);
collectChildNames(node);
setEnabled(true);
return;
}
}
}
}
protected void addMetadataTable() {
// Create a new metadata and Add it on the connection
IProxyRepositoryFactory factory = ProxyRepositoryFactory.getInstance();
metadataTable = ConnectionFactory.eINSTANCE.createMetadataTable();
metadataTable.setId(factory.getNextId());
// initExistingNames();
metadataTable.setLabel(IndiceHelper.getIndexedLabel(metadataTable.getLabel(), existingNames));
EList<SalesforceModuleUnit> modules = temConnection.getModules();
// EList<SalesforceModuleUnit> modules = getConnection().getModules();
for (int i = 0; i < modules.size(); i++) {
if (modules.get(i).getModuleName().equals(moduleName)) {
modules.get(i).getTables().add(modules.get(i).getTables().size(), metadataTable);
break;
}
}
// init TreeNavigator
initTreeNavigatorNodes();
metadataNameText.setText(metadataTable.getLabel());
}
@Override
protected JSONObject getTokenDetailsForCurrentProject() throws Exception {
JSONObject typesHadoop = new JSONObject();
for (IRepositoryViewObject rvo :
ProxyRepositoryFactory.getInstance().getAll(ERepositoryObjectType.getType(HADOOPCLUSTER))) {
HadoopClusterConnectionItem item = (HadoopClusterConnectionItem) rvo.getProperty().getItem();
HadoopClusterConnection connection = (HadoopClusterConnection) item.getConnection();
String distrib =
connection.getDistribution() + "/" + connection.getDfVersion(); // $NON-NLS-1$
int nbDbTypes = 1;
if (typesHadoop.has(distrib)) {
nbDbTypes = typesHadoop.getInt(distrib);
nbDbTypes++;
}
typesHadoop.put(distrib, nbDbTypes);
}
JSONObject hadoopCluster = new JSONObject();
JSONObject types = new JSONObject();
types.put("types", typesHadoop);
hadoopCluster.put(HADOOPCLUSTER, types);
return hadoopCluster;
}
/*
* (non-Javadoc)
*
* @see
* org.talend.designer.core.ICheckNodesService#checkNode(org.talend.designer
* .core.ui.editor.nodes.Node)
*/
public void checkNode(Node node) {
if (!node.getComponent().getName().equals("cCXF")) { // $NON-NLS-1$
return;
}
IElementParameter resourceParam =
node.getElementParameter(EParameterName.ROUTE_RESOURCE_TYPE_ID.getName());
IElementParameter wsdlFileParam = node.getElementParameter("WSDL_FILE"); // $NON-NLS-1$
IElementParameter serviceParam = node.getElementParameter("SERVICE_TYPE"); // $NON-NLS-1$
IElementParameter wsdlTypeParam = node.getElementParameter("WSDL_TYPE"); // $NON-NLS-1$
IElementParameter clazzParam = node.getElementParameter("SERVICE_CLASS"); // $NON-NLS-1$
// Select WSDL
if (serviceParam != null && "wsdlURL".equals(serviceParam.getValue())) { // $NON-NLS-1$
// Select File
if (wsdlTypeParam != null && "file".equals(wsdlTypeParam.getValue())) { // $NON-NLS-1$
// WSDL file is empty
if (wsdlFileParam == null
|| wsdlFileParam.getValue() == null
|| wsdlFileParam.getValue().toString().isEmpty()
|| wsdlFileParam.getValue().toString().equals("\"\"")) { // $NON-NLS-1$
String errorMessage =
MessageFormat.format(
CamelDesignerMessages.getString("CheckCXFNodesService_emptyError") // $NON-NLS-1$
,
wsdlFileParam == null ? "" : wsdlFileParam.getDisplayName());
Problems.add(ProblemStatus.ERROR, (Element) node, errorMessage);
}
} // Select Repository
else if (wsdlTypeParam != null && "repo".equals(wsdlTypeParam.getValue())) { // $NON-NLS-1$
// WSDL file is empty
String errorMessage = ""; // $NON-NLS-1$
if (resourceParam == null
|| resourceParam.getValue() == null
|| resourceParam.getValue().toString().isEmpty()) {
errorMessage =
MessageFormat.format(
CamelDesignerMessages.getString("CheckCXFNodesService_emptyError") // $NON-NLS-1$
,
wsdlFileParam.getDisplayName());
Problems.add(ProblemStatus.ERROR, (Element) node, errorMessage);
} else {
String id = (String) resourceParam.getValue();
try {
IRepositoryViewObject lastVersion =
ProxyRepositoryFactory.getInstance().getLastVersion(id);
if (lastVersion == null) {
errorMessage =
MessageFormat.format(
CamelDesignerMessages.getString(
"CheckCXFNodesService_nonexistError") //$NON-NLS-1$
,
wsdlFileParam.getDisplayName());
Problems.add(ProblemStatus.ERROR, (Element) node, errorMessage);
} else if (lastVersion.isDeleted()) {
errorMessage =
MessageFormat.format(
CamelDesignerMessages.getString(
"CheckCXFNodesService_removedError") //$NON-NLS-1$
,
resourceParam.getDisplayName());
Problems.add(ProblemStatus.ERROR, (Element) node, errorMessage);
}
} catch (PersistenceException e) {
errorMessage =
MessageFormat.format(
CamelDesignerMessages.getString(
"CheckCXFNodesService_emptyError") //$NON-NLS-1$
,
wsdlFileParam.getDisplayName());
Problems.add(ProblemStatus.ERROR, (Element) node, errorMessage);
}
}
}
}
// Select Service class
else if (serviceParam != null
&& "serviceClass".equals(serviceParam.getValue())) { // $NON-NLS-1$
// Service class is empty
if (clazzParam == null
|| clazzParam.getValue() == null
|| clazzParam.getValue().toString().isEmpty()) {
String errorMessage =
MessageFormat.format(
CamelDesignerMessages.getString("CheckCXFNodesService_emptyError") // $NON-NLS-1$
,
wsdlFileParam.getDisplayName());
Problems.add(ProblemStatus.ERROR, (Element) node, errorMessage);
}
}
}
/**
* Create TableFolderNodeRepositoryNode.
*
* @param node parent RepositoryNode
* @param metadataObject parent CatalogViewObject or SchemaViewObject
*/
private void createRepositoryNodeViewFolderNode(
List<IRepositoryNode> node, IRepositoryViewObject metadataObject) {
List<TdView> views = new ArrayList<TdView>();
String filterCharacter = null;
try {
if (metadataObject instanceof MetadataCatalogRepositoryObject) {
viewObject = ((MetadataCatalogRepositoryObject) metadataObject).getViewObject();
if (((MetadataCatalogRepositoryObject) metadataObject).getCatalog().eIsProxy()) {
// reload the connection to make sure the connection(and all it's owned elements) is not
// proxy
reloadConnectionViewObject();
}
catalog = ((MetadataCatalogRepositoryObject) metadataObject).getCatalog();
item = (ConnectionItem) viewObject.getProperty().getItem();
views = PackageHelper.getViews(catalog);
filterCharacter = RepositoryNodeHelper.getViewFilter(catalog, schema);
// MOD gdbu 2011-6-29 bug : 22204
// MOD TDQ-8718 20140505 yyin --the repository view cares about if use the filter or not,
// the column
// select dialog cares about if connect to DB or not.
if (views.isEmpty()) {
connection = item.getConnection();
if (isCallingFromColumnDialog()) {
views =
DqRepositoryViewService.getViews(connection, catalog, null, isLoadDBFromDialog());
} else if (!isOnFilterring()) {
// MOD gdbu 2011-7-21 bug 23220
views = DqRepositoryViewService.getViews(connection, catalog, null, true);
}
if (views != null && views.size() > 0) {
ProxyRepositoryFactory.getInstance().save(item, false);
}
}
ConnectionUtils.retrieveColumn(views);
// ~22204
} else if (metadataObject instanceof MetadataSchemaRepositoryObject) {
viewObject = ((MetadataSchemaRepositoryObject) metadataObject).getViewObject();
if (((MetadataSchemaRepositoryObject) metadataObject).getSchema().eIsProxy()) {
// reload the connection to make sure the connection(and all it's owned elements) is not
// proxy
reloadConnectionViewObject();
}
schema = ((MetadataSchemaRepositoryObject) metadataObject).getSchema();
item = (ConnectionItem) viewObject.getProperty().getItem();
views = PackageHelper.getViews(schema);
filterCharacter = RepositoryNodeHelper.getViewFilter(catalog, schema);
RepositoryNode parent = metadataObject.getRepositoryNode().getParent();
IRepositoryViewObject object = parent.getObject();
if (object instanceof MetadataCatalogRepositoryObject
&& filterCharacter.equals(PluginConstant.EMPTY_STRING)) {
filterCharacter =
RepositoryNodeHelper.getViewFilter(
((MetadataCatalogRepositoryObject) object).getCatalog(), null);
}
// MOD gdbu 2011-6-29 bug : 22204
if (views.isEmpty()) {
connection = item.getConnection();
if (isCallingFromColumnDialog()) {
views =
DqRepositoryViewService.getViews(connection, schema, null, isLoadDBFromDialog());
} else if (!isOnFilterring()) {
// MOD gdbu 2011-7-21 bug 23220
views = DqRepositoryViewService.getViews(connection, schema, null, true);
}
if (views != null && views.size() > 0) {
ProxyRepositoryFactory.getInstance().save(item, false);
}
} else {
ConnectionUtils.retrieveColumn(views);
}
// ~22204
}
} catch (Exception e) {
log.error(e, e);
}
if (filterCharacter != null && !filterCharacter.equals(PluginConstant.EMPTY_STRING)) {
views = RepositoryNodeHelper.filterViews(views, filterCharacter);
}
createViewRepositoryNode(views, node);
}
/*
* (non-Javadoc)
*
* @see org.talend.repository.ui.actions.ITreeContextualAction#init(org.eclipse.jface.viewers.TreeViewer,
* org.eclipse.jface.viewers.IStructuredSelection)
*/
@Override
public void init(TreeViewer viewer, IStructuredSelection selection) {
boolean canWork = !selection.isEmpty() && selection.size() == 1;
IProxyRepositoryFactory factory = ProxyRepositoryFactory.getInstance();
if (factory.isUserReadOnlyOnCurrentProject()) {
canWork = false;
}
if (canWork) {
Object o = selection.getFirstElement();
RepositoryNode node = (RepositoryNode) o;
Object property = node.getProperties(EProperties.CONTENT_TYPE);
switch (node.getType()) {
case REPOSITORY_ELEMENT:
case STABLE_SYSTEM_FOLDER:
canWork = false;
break;
case SYSTEM_FOLDER:
if (ERepositoryObjectType.GENERATED.equals(property)
|| ERepositoryObjectType.JOBS.equals(property)
|| ERepositoryObjectType.JOBLETS.equals(property)
|| ERepositoryObjectType.SQLPATTERNS.equals(property)
|| ERepositoryObjectType.REFERENCED_PROJECTS.equals(property)
|| ERepositoryObjectType.SVN_ROOT.equals(property)) {
canWork = false;
} else if (property != null
&& GlobalServiceRegister.getDefault()
.isServiceRegistered(ICamelDesignerCoreService.class)) {
ICamelDesignerCoreService camelService =
(ICamelDesignerCoreService)
GlobalServiceRegister.getDefault().getService(ICamelDesignerCoreService.class);
if (property.equals(camelService.getRouteDocsType())) {
canWork = false;
}
}
break;
case SIMPLE_FOLDER:
if (ERepositoryObjectType.JOB_DOC.equals(property)
|| ERepositoryObjectType.JOBLET_DOC.equals(property)
|| (ERepositoryObjectType.SQLPATTERNS.equals(property)
&& !isUnderUserDefined(node))) {
canWork = false;
} else if (property != null
&& GlobalServiceRegister.getDefault()
.isServiceRegistered(ICamelDesignerCoreService.class)) {
ICamelDesignerCoreService camelService =
(ICamelDesignerCoreService)
GlobalServiceRegister.getDefault().getService(ICamelDesignerCoreService.class);
if (property.equals(camelService.getRouteDocType())) {
canWork = false;
}
}
if (node.getObject().isDeleted()) {
canWork = false;
}
break;
default:
// Nothing to do
}
if (canWork && !ProjectManager.getInstance().isInCurrentMainProject(node)) {
canWork = false;
}
}
setEnabled(canWork);
}
public void importItemRecords(
final IProgressMonitor progressMonitor,
final ResourcesManager resManager,
final List<ImportItem> checkedItemRecords,
final boolean overwrite,
final ImportItem[] allImportItemRecords,
final IPath destinationPath)
throws InvocationTargetException {
TimeMeasure.display = CommonsPlugin.isDebugMode();
TimeMeasure.displaySteps = CommonsPlugin.isDebugMode();
TimeMeasure.measureActive = CommonsPlugin.isDebugMode();
TimeMeasure.begin("ImportingItems"); // $NON-NLS-1$
/*
* Re-order the import items according to the priority of extension point.
*/
final List<IImportItemsHandler> importItemHandlersList =
new ArrayList<IImportItemsHandler>(Arrays.asList(getImportHandlers()));
Collections.sort(
checkedItemRecords,
new Comparator<ImportItem>() {
@Override
public int compare(ImportItem o1, ImportItem o2) {
IImportItemsHandler importHandler1 = o1.getImportHandler();
IImportItemsHandler importHandler2 = o2.getImportHandler();
if (importHandler1 != null && importHandler2 != null) {
int index1 = importItemHandlersList.indexOf(importHandler1);
int index2 = importItemHandlersList.indexOf(importHandler2);
if (index1 > -1 && index2 > -1) { // both found
return index1 - index2;
}
}
return 0;
}
});
ImportCacheHelper importCacheHelper = ImportCacheHelper.getInstance();
try {
// cache
importCacheHelper.beforeImportItems();
if (resManager == null || checkedItemRecords.isEmpty()) {
return;
}
progressMonitor.beginTask(
Messages.getString("ImportExportHandlersManager_importingItemsMessage"),
checkedItemRecords.size() * 2 + 1); // $NON-NLS-1$
/*
* FIXME ????? why need sort it?
*
* Maybe, Have done by priority for import handler, so no need.
*/
// Collections.sort(itemRecords, new Comparator<ImportItem>() {
//
// @Override
// public int compare(ImportItem o1, ImportItem o2) {
// if (o1.getProperty().getItem() instanceof RoutineItem && o2.getProperty().getItem()
// instanceof
// RoutineItem) {
// return 0;
// } else if (!(o1.getProperty().getItem() instanceof RoutineItem)
// && !(o2.getProperty().getItem() instanceof RoutineItem)) {
// return 0;
// } else if (o1.getProperty().getItem() instanceof RoutineItem) {
// return -1;
// } else {
// return 1;
// }
// }
// });
//
RepositoryWorkUnit repositoryWorkUnit =
new RepositoryWorkUnit(
Messages.getString(
"ImportExportHandlersManager_importingItemsMessage")) { //$NON-NLS-1$
@Override
public void run() throws PersistenceException {
final IWorkspaceRunnable op =
new IWorkspaceRunnable() {
@Override
public void run(final IProgressMonitor monitor) throws CoreException {
// pre import
preImport(
monitor,
resManager,
checkedItemRecords.toArray(new ImportItem[0]),
allImportItemRecords);
// bug 10520
final Set<String> overwriteDeletedItems = new HashSet<String>();
final Set<String> idDeletedBeforeImport = new HashSet<String>();
Map<String, String> nameToIdMap = new HashMap<String, String>();
for (ImportItem itemRecord : checkedItemRecords) {
if (monitor.isCanceled()) {
return;
}
if (itemRecord.isValid()) {
if (itemRecord.getState() == State.ID_EXISTED) {
String id =
nameToIdMap.get(
itemRecord.getProperty().getLabel()
+ ERepositoryObjectType.getItemType(
itemRecord.getProperty().getItem())
.toString());
if (id == null) {
/*
* if id exsist then need to genrate new id for this job,in this case the
* job won't override the old one
*/
id = EcoreUtil.generateUUID();
nameToIdMap.put(
itemRecord.getProperty().getLabel()
+ ERepositoryObjectType.getItemType(
itemRecord.getProperty().getItem())
.toString(),
id);
}
itemRecord.getProperty().setId(id);
}
}
}
try {
importItemRecordsWithRelations(
monitor,
resManager,
checkedItemRecords,
overwrite,
allImportItemRecords,
destinationPath,
overwriteDeletedItems,
idDeletedBeforeImport);
} catch (Exception e) {
if (Platform.inDebugMode()) {
ExceptionHandler.process(e);
}
throw new CoreException(
new Status(
IStatus.ERROR,
FrameworkUtil.getBundle(this.getClass()).getSymbolicName(),
Messages.getString(
"ImportExportHandlersManager_importingItemsError"),
e)); //$NON-NLS-1$
}
if (PluginChecker.isJobLetPluginLoaded()) {
IJobletProviderService service =
(IJobletProviderService)
GlobalServiceRegister.getDefault()
.getService(IJobletProviderService.class);
if (service != null) {
service.loadComponentsFromProviders();
}
}
ImportCacheHelper.getInstance().checkDeletedFolders();
monitor.done();
TimeMeasure.step(
"importItemRecords", "before save"); // $NON-NLS-1$ //$NON-NLS-2$
if (RelationshipItemBuilder.getInstance().isNeedSaveRelations()) {
RelationshipItemBuilder.getInstance().saveRelations();
TimeMeasure.step(
"importItemRecords", "save relations"); // $NON-NLS-1$ //$NON-NLS-2$
} else {
// only save the project here if no relation need to be saved, since project
// will
// already be
// saved
// with relations
try {
final IProxyRepositoryFactory factory =
CoreRuntimePlugin.getInstance().getProxyRepositoryFactory();
factory.saveProject(ProjectManager.getInstance().getCurrentProject());
} catch (PersistenceException e) {
if (Platform.inDebugMode()) {
ExceptionHandler.process(e);
}
throw new CoreException(
new Status(
IStatus.ERROR,
FrameworkUtil.getBundle(this.getClass()).getSymbolicName(),
Messages.getString(
"ImportExportHandlersManager_importingItemsError"),
e)); //$NON-NLS-1$
}
TimeMeasure.step(
"importItemRecords", "save project"); // $NON-NLS-1$//$NON-NLS-2$
}
// post import
List<ImportItem> importedItemRecords =
ImportCacheHelper.getInstance().getImportedItemRecords();
postImport(
monitor, resManager, importedItemRecords.toArray(new ImportItem[0]));
}
private void importItemRecordsWithRelations(
final IProgressMonitor monitor,
final ResourcesManager manager,
final List<ImportItem> processingItemRecords,
final boolean overwriting,
ImportItem[] allPopulatedImportItemRecords,
IPath destinationPath,
final Set<String> overwriteDeletedItems,
final Set<String> idDeletedBeforeImport)
throws Exception {
for (ImportItem itemRecord : processingItemRecords) {
if (monitor.isCanceled()) {
return;
}
if (itemRecord.isImported()) {
continue; // have imported
}
try {
final IImportItemsHandler importHandler = itemRecord.getImportHandler();
if (importHandler != null && itemRecord.isValid()) {
List<ImportItem> relatedItemRecord =
importHandler.findRelatedImportItems(
monitor, manager, itemRecord, allPopulatedImportItemRecords);
// import related items first
if (importHandler.isPriorImportRelatedItem()) {
if (!relatedItemRecord.isEmpty()) {
importItemRecordsWithRelations(
monitor,
manager,
relatedItemRecord,
overwriting,
allPopulatedImportItemRecords,
destinationPath,
overwriteDeletedItems,
idDeletedBeforeImport);
}
}
if (monitor.isCanceled()) {
return;
}
// will import
importHandler.doImport(
monitor,
manager,
itemRecord,
overwriting,
destinationPath,
overwriteDeletedItems,
idDeletedBeforeImport);
if (monitor.isCanceled()) {
return;
}
// if import related items behind current item
if (!importHandler.isPriorImportRelatedItem()) {
if (!relatedItemRecord.isEmpty()) {
importItemRecordsWithRelations(
monitor,
manager,
relatedItemRecord,
overwriting,
allPopulatedImportItemRecords,
destinationPath,
overwriteDeletedItems,
idDeletedBeforeImport);
}
}
importHandler.afterImportingItems(monitor, manager, itemRecord);
// record the imported items with related items too.
ImportCacheHelper.getInstance()
.getImportedItemRecords()
.add(itemRecord);
monitor.worked(1);
}
} catch (Exception e) {
// ???, PTODO if there one error, need throw error or not.
if (Platform.inDebugMode()) {
// FIXME, catch the exception, and don't block others to import
itemRecord.addError(e.getMessage());
// same the the ImportBasicHandler.logError
ImportCacheHelper.getInstance().setImportingError(true);
ExceptionHandler.process(e);
}
}
}
}
};
IWorkspace workspace = ResourcesPlugin.getWorkspace();
try {
ISchedulingRule schedulingRule = workspace.getRoot();
// the update the project files need to be done in the workspace runnable to avoid
// all
// notification
// of changes before the end of the modifications.
workspace.run(op, schedulingRule, IWorkspace.AVOID_UPDATE, progressMonitor);
} catch (CoreException e) {
if (Platform.inDebugMode()) {
ExceptionHandler.process(e);
}
}
}
};
repositoryWorkUnit.setAvoidUnloadResources(true);
repositoryWorkUnit.setUnloadResourcesAfterRun(true);
ProxyRepositoryFactory.getInstance().executeRepositoryWorkUnit(repositoryWorkUnit);
progressMonitor.done();
if (ImportCacheHelper.getInstance().hasImportingError()) {
throw new InvocationTargetException(
new CoreException(
new Status(
IStatus.ERROR,
FrameworkUtil.getBundle(this.getClass()).getSymbolicName(),
Messages.getString(
"ImportExportHandlersManager_importingItemsError")))); //$NON-NLS-1$
}
} finally {
// cache
importCacheHelper.afterImportItems();
//
TimeMeasure.end("ImportingItems"); // $NON-NLS-1$
TimeMeasure.display = false;
TimeMeasure.displaySteps = false;
TimeMeasure.measureActive = false;
}
}
/*
* (non-Javadoc)
*
* @see org.eclipse.jface.dialogs.IDialogPage#createControl(org.eclipse.swt.widgets.Composite)
*/
public void createControl(Composite parent) {
// TODO Auto-generated method stub
currentComposite = null;
WSDLSchemaConnection connection = ((WSDLSchemaConnection) connectionItem.getConnection());
if (ConnectionHelper.getTables(connection).size() < 2) {
MetadataTable metadataTable =
ConnectionHelper.getTables(connection).toArray(new MetadataTable[0])[0];
metadataTable.setLabel("Output");
MetadataTable inPutMetadataTable = ConnectionFactory.eINSTANCE.createMetadataTable();
IProxyRepositoryFactory factory = ProxyRepositoryFactory.getInstance();
inPutMetadataTable.setLabel("Input");
inPutMetadataTable.setId(factory.getNextId());
GenericPackage g =
(GenericPackage)
ConnectionHelper.getPackage(
connection.getName(), (Connection) connection, GenericPackage.class);
if (g != null) { // hywang
g.getOwnedElement().add(inPutMetadataTable);
ConnectionHelper.getTables(connection).add(inPutMetadataTable);
} else {
GenericPackage gpkg = ConnectionFactory.eINSTANCE.createGenericPackage();
PackageHelper.addMetadataTable(inPutMetadataTable, gpkg);
ConnectionHelper.addPackage(gpkg, connection);
}
// connection.getTables().add(inPutMetadataTable);
}
switch (step) {
case 2:
currentComposite =
new WebServiceStep1Form(
parent, connectionItem, null, new String[] {}, contextModeManager);
break;
case 3:
MetadataTable metadataTable2 = null;
Set<MetadataTable> tables = ConnectionHelper.getTables(connection);
Iterator<MetadataTable> it = tables.iterator();
while (it.hasNext()) {
MetadataTable table = (MetadataTable) it.next();
if (table.getLabel().equals("Output")) {
metadataTable2 = table;
}
}
currentComposite =
new WebServiceStep2Form(parent, connectionItem, contextModeManager, metadataTable2);
break;
default:
System.out.println("error...");
}
currentComposite.setReadOnly(!isRepositoryObjectEditable);
AbstractForm.ICheckListener listener =
new AbstractForm.ICheckListener() {
public void checkPerformed(final AbstractForm source) {
if (source.isStatusOnError()) {
WebServiceSchemaWizardPage.this.setPageComplete(false);
setErrorMessage(source.getStatus());
} else {
WebServiceSchemaWizardPage.this.setPageComplete(isRepositoryObjectEditable);
setErrorMessage(null);
setMessage(source.getStatus());
}
}
};
currentComposite.setListener(listener);
setControl((Composite) currentComposite);
}
public SalesforceSchemaWizard(
IWorkbench workbench,
boolean creation,
RepositoryNode node,
String[] existingNames,
boolean isSinglePageOnly) {
super(workbench, creation);
this.existingNames = existingNames;
this.isSinglePageOnly = isSinglePageOnly;
setNeedsProgressMonitor(true);
// TODO: should to changed icon.
setDefaultPageImageDescriptor(ImageProvider.getImageDesc(ECoreImage.DEFAULT_WIZ));
switch (node.getType()) {
case SIMPLE_FOLDER:
case REPOSITORY_ELEMENT:
pathToSave = RepositoryNodeUtilities.getPath(node);
break;
case SYSTEM_FOLDER:
pathToSave = new Path(""); // $NON-NLS-1$
break;
}
switch (node.getType()) {
case SIMPLE_FOLDER:
case SYSTEM_FOLDER:
connection = ConnectionFactory.eINSTANCE.createSalesforceSchemaConnection();
connection.setName(ERepositoryObjectType.METADATA_SALESFORCE_SCHEMA.getKey());
MetadataTable metadataTable = ConnectionFactory.eINSTANCE.createMetadataTable();
IProxyRepositoryFactory factory = ProxyRepositoryFactory.getInstance();
metadataTable.setId(factory.getNextId());
RecordFile record =
(RecordFile)
ConnectionHelper.getPackage(connection.getName(), connection, RecordFile.class);
if (record != null) { // hywang
PackageHelper.addMetadataTable(metadataTable, record);
} else {
RecordFile newrecord = RecordFactory.eINSTANCE.createRecordFile();
newrecord.setName(connection.getName());
ConnectionHelper.addPackage(newrecord, connection);
PackageHelper.addMetadataTable(metadataTable, newrecord);
}
connectionProperty = PropertiesFactory.eINSTANCE.createProperty();
connectionProperty.setAuthor(
((RepositoryContext)
CoreRuntimePlugin.getInstance()
.getContext()
.getProperty(Context.REPOSITORY_CONTEXT_KEY))
.getUser());
connectionProperty.setVersion(VersionUtils.DEFAULT_VERSION);
connectionProperty.setStatusCode(""); // $NON-NLS-1$
connectionItem = PropertiesFactory.eINSTANCE.createSalesforceSchemaConnectionItem();
connectionItem.setProperty(connectionProperty);
connectionItem.setConnection(connection);
initProxySettings(connection);
break;
case REPOSITORY_ELEMENT:
connection =
(SalesforceSchemaConnection)
((ConnectionItem) node.getObject().getProperty().getItem()).getConnection();
connectionProperty = node.getObject().getProperty();
connectionItem = (ConnectionItem) node.getObject().getProperty().getItem();
// set the repositoryObject, lock and set isRepositoryObjectEditable
setRepositoryObject(node.getObject());
isRepositoryObjectEditable();
initLockStrategy();
break;
}
if (!creation) {
this.originaleObjectLabel = this.connectionItem.getProperty().getLabel();
this.originalVersion = this.connectionItem.getProperty().getVersion();
this.originalDescription = this.connectionItem.getProperty().getDescription();
this.originalPurpose = this.connectionItem.getProperty().getPurpose();
this.originalStatus = this.connectionItem.getProperty().getStatusCode();
}
initConnection();
}
@Override
public void run() {
SaveAsBusinessModelWizard businessModelWizard = new SaveAsBusinessModelWizard(editorPart);
WizardDialog dlg = new WizardDialog(Display.getCurrent().getActiveShell(), businessModelWizard);
if (dlg.open() == Window.OK) {
try {
BusinessProcessItem businessProcessItem = businessModelWizard.getBusinessProcessItem();
IRepositoryNode repositoryNode =
RepositoryNodeUtilities.getRepositoryNode(
businessProcessItem.getProperty().getId(), false);
// because step1, the fresh will unload the resource(EMF), so, assign a new one...
businessProcessItem =
(BusinessProcessItem) repositoryNode.getObject().getProperty().getItem();
IWorkbenchPage page = getActivePage();
DiagramResourceManager diagramResourceManager =
new DiagramResourceManager(page, new NullProgressMonitor());
IFile file = businessModelWizard.getTempFile();
// Set readonly to false since created job will always be editable.
RepositoryEditorInput newBusinessModelEditorInput =
new RepositoryEditorInput(file, businessProcessItem);
newBusinessModelEditorInput.setRepositoryNode(repositoryNode);
// here really do the normal save as function
IDocumentProvider provider =
((BusinessDiagramEditor) this.editorPart).getDocumentProvider();
provider.aboutToChange(newBusinessModelEditorInput);
provider.saveDocument(
null,
newBusinessModelEditorInput,
provider.getDocument(this.editorPart.getEditorInput()),
true);
provider.changed(newBusinessModelEditorInput);
// copy back from the *.business_diagram file to *.item file.
// @see:BusinessDiagramEditor.doSave(IProgressMonitor progressMonitor)
diagramResourceManager.updateFromResource(
businessProcessItem, newBusinessModelEditorInput.getFile());
// notice: here, must save it, save the item to disk, otherwise close the editor
// without any modification, there won't save the
// model again, so, will lost the graphic when reopen it.
ProxyRepositoryFactory.getInstance().save(businessProcessItem);
// close the old editor
page.closeEditor(this.editorPart, false);
// open the new editor, because at the same time, there will update the
// jobSetting/componentSetting view
IEditorPart openEditor =
page.openEditor(newBusinessModelEditorInput, BusinessDiagramEditor.ID, true);
} catch (Exception e) {
MessageDialog.openError(
Display.getCurrent().getActiveShell(),
"Error",
"Business model could not be saved" + " : " + e.getMessage());
ExceptionHandler.process(e);
}
}
}
public abstract class SingleTopLevelContentProvider implements ITreeContentProvider {
private final IProxyRepositoryFactory factory = ProxyRepositoryFactory.getInstance();
protected static final Object[] NO_CHILDREN = new Object[0];
// this is a temporary fix, the content provider should not hold the top level nodes at all.
private Set<RepositoryNode> topLevelNodes =
PredicatedSet.decorate(new HashSet<RepositoryNode>(), NotNullPredicate.INSTANCE);
// private ProjectRepositoryNode projectRepositoryNode;
/**
* Getter for topLevelNode.
*
* @return the topLevelNode
*/
public Set<RepositoryNode> getTopLevelNodes() {
return topLevelNodes;
}
// private RepositoryNode rootNode;
/**
* Getter for projectRepositoryNode.
*
* @return the projectRepositoryNode
*/
// public ProjectRepositoryNode getProjectRepositoryNode() {
// return this.projectRepositoryNode;
// }
protected IProxyRepositoryFactory getFactory() {
return factory;
}
@Override
public Object[] getElements(Object inputElement) { // check for ProjectRepositoryNode parent
return getChildren(inputElement);
}
/**
* Called when getting the single root element for this Content Provider. This is called only once
* if the return value is not null
*
* @param the root node, never null
* @return the first and single item object for this content provider
*/
protected abstract RepositoryNode getInitialTopLevelNode(RepositoryNode theRootNode);
/*
* this must be called only with a node that is return true when isRootNodeType(repositoryNode) is called This will
* ask for top level node and store is in the internal set.
*/
protected RepositoryNode getAndStoreTopLevelNode(RepositoryNode repositoryNode) {
RepositoryNode aTopLevelNode = getInitialTopLevelNode(repositoryNode);
if (aTopLevelNode != null) {
boolean isNewTopLevel = topLevelNodes.add(aTopLevelNode);
if (isNewTopLevel) { // initialize it
initilizeContentProviderWithTopLevelNode(aTopLevelNode);
} // else already added so no need to initialised
} // else not top level node so return null
return aTopLevelNode;
}
/**
* This is called the first time the TopLevelnode is created and store in this content provider.
* Used to initialized content provider with the new topLevel. reset the top level node in this
* implmentation.
*
* @param aTopLevelNode, never null
*/
protected void initilizeContentProviderWithTopLevelNode(RepositoryNode aTopLevelNode) {
resetTopLevelNode(aTopLevelNode);
}
/**
* this is called when the model has changed and we need to reset the top level node for the next
* refresh. At the next refresh the model will be constructed again.
*/
protected void resetTopLevelNode(RepositoryNode aTopLevelNode) {
if (aTopLevelNode != null) { // reset top level node
aTopLevelNode.setInitialized(false);
aTopLevelNode.getChildren().clear();
}
// initRepositoryNode(topLevelNode2);
}
/**
* this returnt the children for any type handle by this class. It first check if the element is a
* potential root node, if so it store it. if element is the root node then getTopLevelNode is
* called to get the single children if it is some other nodes it can handle is returns their
* children by delegating to the getRepositoryNodeChildren or returns none.
*/
@Override
public Object[] getChildren(Object element) {
RepositoryNode theRootNode = null;
// store the root node
if (isRootNodeType(element)) {
theRootNode = extractPotentialRootNode(element);
}
// if root then return the top level node
if (theRootNode != null) {
IRepositoryNode cachedTopLevelNode = getAndStoreTopLevelNode(theRootNode);
return cachedTopLevelNode != null ? new Object[] {cachedTopLevelNode} : NO_CHILDREN;
} else if (element instanceof RepositoryNode) { // else return children
// // check that element is top level node or a children of it
RepositoryNode repositoryNode = (RepositoryNode) element;
return getRepositoryNodeChildren(repositoryNode);
} // else not a root node and not a child not so ignors it
return NO_CHILDREN;
}
/**
* DOC sgandon Comment method "isRootNode".
*
* @param element
* @return
*/
protected abstract boolean isRootNodeType(Object element);
/**
* extract a potention root node. This is called right after checking type by calling
* isRootNodeType so the check does not need to be done again.
*
* @param element used to find a potential root node
* @return the potential rootNode or null.
*/
protected abstract RepositoryNode extractPotentialRootNode(Object element);
/**
* DOC sgandon Comment method "getRepositoryNodeChildren".
*
* @param element
* @param repositoryNode
* @return
*/
protected Object[] getRepositoryNodeChildren(RepositoryNode repositoryNode) {
if (!repositoryNode.isInitialized()) {
if (repositoryNode.getParent() instanceof ProjectRepositoryNode) {
// initialize repository from main project
initializeChildren(repositoryNode);
} // else sub sub node so no need to initialize
repositoryNode.setInitialized(true);
} // else already initialised
return repositoryNode.getChildren().toArray();
}
protected void initializeChildren(RepositoryNode parent) {
((ProjectRepositoryNode) parent.getParent()).initializeChildren(parent);
}
@Override
public Object getParent(Object element) {
return null;
}
@Override
public boolean hasChildren(Object element) {
Boolean boolean1 = factory.hasChildren(element);
if (boolean1 != null) {
return boolean1;
} else {
if (element instanceof RepositoryNode) {
final RepositoryNode repositoryNode = (RepositoryNode) element;
if (repositoryNode.isInitialized()) {
return repositoryNode.hasChildren();
} else {
return getChildren(element).length > 0;
}
}
return true;
}
}
/*
* (non-Javadoc)
*
* @see org.eclipse.jface.viewers.IContentProvider#dispose()
*/
@Override
public void dispose() {
// to help garbage collection
topLevelNodes.clear();
// topLevelNodes = null;
}
/*
* (non-Javadoc)
*
* @see
* org.talend.repository.viewer.content.ProjectRepoDirectChildrenNodeContentProvider#inputChanged(org.eclipse.jface
* .viewers.Viewer, java.lang.Object, java.lang.Object)
*/
@Override
public void inputChanged(Viewer arg0, Object arg1, Object arg2) {
// FIXME by TDI-22701, If the input model has been changed, so need clean
topLevelNodes.clear();
}
}
