use of org.talend.commons.runtime.model.repository.ERepositoryStatus in project tdi-studio-se by Talend.
the class ImportItemUtil method importItemRecord.
private void importItemRecord(ResourcesManager manager, ItemRecord itemRecord, boolean overwrite, IPath destinationPath, final Set<String> overwriteDeletedItems, final Set<String> idDeletedBeforeImport, String contentType, final IProgressMonitor monitor) {
//$NON-NLS-1$
monitor.subTask(Messages.getString("ImportItemWizardPage.Importing") + itemRecord.getItemName());
resolveItem(manager, itemRecord);
if (!itemRecord.isValid()) {
return;
}
int num = 0;
for (Object obj : itemRecord.getResourceSet().getResources()) {
if (!(obj instanceof PropertiesProjectResourceImpl)) {
if (obj instanceof XMIResourceImpl) {
num++;
if (num > 2) {
// 2 so that metadata migration for 4.1 works
try {
throw new InvocationTargetException(new PersistenceException("The source file of " + itemRecord.getLabel() + " has error,Please check it!"));
} catch (InvocationTargetException e) {
ExceptionHandler.process(e);
}
return;
}
}
}
}
final Item item = itemRecord.getItem();
if (item != null) {
ProxyRepositoryFactory repFactory = ProxyRepositoryFactory.getInstance();
ERepositoryObjectType itemType = ERepositoryObjectType.getItemType(item);
IPath path = new Path(item.getState().getPath());
if (destinationPath != null && itemType.name().equals(contentType)) {
path = destinationPath.append(path);
}
try {
FolderItem folderItem = repFactory.getFolderItem(ProjectManager.getInstance().getCurrentProject(), itemType, path);
if (folderItem == null) {
// if this folder does not exists (and it's parents), it will check if the folder was originally
// deleted in source project.
// if yes, it will set back the delete status to the folder, to keep the same as the original
// project when import.
// Without this code, deleted folders of items imported will not be in the recycle bin after import.
// delete status is set finally in the function checkDeletedFolders
IPath curPath = path;
EList deletedFoldersFromOriginalProject = itemRecord.getItemProject().getDeletedFolders();
while (folderItem == null && !curPath.isEmpty() && !curPath.isRoot()) {
if (deletedFoldersFromOriginalProject.contains(new Path(itemType.getFolder()).append(curPath.toPortableString()).toPortableString())) {
if (!foldersCreated.containsKey(itemType)) {
foldersCreated.put(itemType, new HashSet<String>());
}
foldersCreated.get(itemType).add(curPath.toPortableString());
}
if (curPath.segments().length > 0) {
curPath = curPath.removeLastSegments(1);
folderItem = repFactory.getFolderItem(ProjectManager.getInstance().getCurrentProject(), itemType, curPath);
}
}
}
repFactory.createParentFoldersRecursively(ProjectManager.getInstance().getCurrentProject(), itemType, path, true);
} catch (Exception e) {
logError(e);
//$NON-NLS-1$
path = new Path("");
}
try {
Item tmpItem = item;
// delete existing items before importing, this should be done
// once for a different id
String id = itemRecord.getProperty().getId();
IRepositoryViewObject lastVersion = itemRecord.getExistingItemWithSameId();
if (lastVersion != null && overwrite && !itemRecord.isLocked() && (itemRecord.getState() == State.ID_EXISTED || itemRecord.getState() == State.NAME_EXISTED || itemRecord.getState() == State.NAME_AND_ID_EXISTED) && !deletedItems.contains(id)) {
if (!overwriteDeletedItems.contains(id)) {
// bug 10520.
ERepositoryStatus status = repFactory.getStatus(lastVersion);
if (status == ERepositoryStatus.DELETED) {
// restore first.
repFactory.restoreObject(lastVersion, path);
}
overwriteDeletedItems.add(id);
}
/* only delete when name exsit rather than id exist */
if (itemRecord.getState().equals(ItemRecord.State.NAME_EXISTED) || itemRecord.getState().equals(ItemRecord.State.NAME_AND_ID_EXISTED)) {
if (!idDeletedBeforeImport.contains(id)) {
// TDI-19535 (check if exists, delete all items with same id)
List<IRepositoryViewObject> allVersionToDelete = repFactory.getAllVersion(ProjectManager.getInstance().getCurrentProject(), lastVersion.getId(), false);
String importingLabel = itemRecord.getProperty().getLabel();
String existLabel = lastVersion.getProperty().getLabel();
for (IRepositoryViewObject currentVersion : allVersionToDelete) {
repFactory.forceDeleteObjectPhysical(lastVersion, currentVersion.getVersion(), isNeedDeleteOnRemote(importingLabel, existLabel));
}
idDeletedBeforeImport.add(id);
}
}
lastVersion = null;
// List<IRepositoryObject> list = cache.findObjectsByItem(itemRecord);
// if (!list.isEmpty()) {
// // this code will delete all version of item with same
// // id
// repFactory.forceDeleteObjectPhysical(list.get(0));
// deletedItems.add(id);
// }
}
User author = itemRecord.getProperty().getAuthor();
if (author != null) {
if (!repFactory.setAuthorByLogin(tmpItem, author.getLogin())) {
// author will be
tmpItem.getProperty().setAuthor(null);
// the logged
// user in
// create method
}
}
if (item instanceof JobletProcessItem) {
hasJoblets = true;
}
if (tmpItem instanceof ProcessItem && !statAndLogsSettingsReloaded && !implicitSettingsReloaded) {
ProcessItem processItem = (ProcessItem) tmpItem;
ParametersType paType = processItem.getProcess().getParameters();
boolean statsPSettingRemoved = false;
// for commanline import project setting
if (itemRecord.isRemoveProjectStatslog()) {
if (paType != null) {
String paramName = "STATANDLOG_USE_PROJECT_SETTINGS";
EList listParamType = paType.getElementParameter();
for (int j = 0; j < listParamType.size(); j++) {
ElementParameterType pType = (ElementParameterType) listParamType.get(j);
if (pType != null && paramName.equals(pType.getName())) {
pType.setValue(Boolean.FALSE.toString());
statsPSettingRemoved = true;
break;
}
}
}
}
// 14446: item apply project setting param if use project setting
String statslogUsePSetting = null;
String implicitUsePSetting = null;
if (paType != null) {
EList listParamType = paType.getElementParameter();
for (int j = 0; j < listParamType.size(); j++) {
ElementParameterType pType = (ElementParameterType) listParamType.get(j);
if (pType != null) {
if (!statsPSettingRemoved && "STATANDLOG_USE_PROJECT_SETTINGS".equals(pType.getName())) {
statslogUsePSetting = pType.getValue();
}
if ("IMPLICITCONTEXT_USE_PROJECT_SETTINGS".equals(pType.getName())) {
implicitUsePSetting = pType.getValue();
}
if (statsPSettingRemoved && implicitUsePSetting != null || !statsPSettingRemoved && implicitUsePSetting != null && statslogUsePSetting != null) {
break;
}
}
}
}
if (statslogUsePSetting != null && Boolean.parseBoolean(statslogUsePSetting) && !statAndLogsSettingsReloaded) {
CorePlugin.getDefault().getDesignerCoreService().reloadParamFromProjectSettings(paType, "STATANDLOG_USE_PROJECT_SETTINGS");
statAndLogsSettingsReloaded = true;
}
if (implicitUsePSetting != null && Boolean.parseBoolean(implicitUsePSetting) && !implicitSettingsReloaded) {
CorePlugin.getDefault().getDesignerCoreService().reloadParamFromProjectSettings(paType, "IMPLICITCONTEXT_USE_PROJECT_SETTINGS");
implicitSettingsReloaded = true;
}
}
if (lastVersion == null || itemRecord.getState().equals(ItemRecord.State.ID_EXISTED)) {
// import has not been developed to cope with migration in mind
// so some model may not be able to load like the ConnectionItems
// in that case items needs to be copied before migration
// here we check that the loading of the item failed before calling the create method
boolean isConnectionEmptyBeforeMigration = tmpItem instanceof ConnectionItem && ((ConnectionItem) tmpItem).getConnection().eResource() == null && !itemRecord.getMigrationTasksToApply().isEmpty();
repFactory.create(tmpItem, path, true);
if (isConnectionEmptyBeforeMigration) {
// copy the file before migration, this is bad because it
// should not refer to Filesytem
// but this is a quick hack and anyway the migration task only works on files
// IPath itemPath = itemRecord.getPath().removeFileExtension().addFileExtension(
// FileConstants.ITEM_EXTENSION);
InputStream is = manager.getStream(itemRecord.getPath().removeFileExtension().addFileExtension(FileConstants.ITEM_EXTENSION));
try {
URI propertyResourceURI = EcoreUtil.getURI(((ConnectionItem) tmpItem).getProperty());
URI relativePlateformDestUri = propertyResourceURI.trimFileExtension().appendFileExtension(FileConstants.ITEM_EXTENSION);
URL fileURL = FileLocator.toFileURL(new java.net.URL(//$NON-NLS-1$
"platform:/resource" + relativePlateformDestUri.toPlatformString(true)));
OutputStream os = new FileOutputStream(fileURL.getFile());
try {
FileCopyUtils.copyStreams(is, os);
} finally {
os.close();
}
} finally {
is.close();
}
repFactory.unloadResources(tmpItem.getProperty());
} else {
// connections from migrations (from 4.0.x or previous version) doesn't support reference or
// screenshots
// so no need to call this code.
// It's needed to avoid to call the save method mainly just before or after the copy of the old
// connection since it will
copyScreenshotFile(manager, itemRecord);
boolean haveRef = copyReferenceFiles(manager, tmpItem, itemRecord.getPath());
if (haveRef) {
repFactory.save(tmpItem, true);
}
}
itemRecord.setImportPath(path.toPortableString());
itemRecord.setRepositoryType(itemType);
itemRecord.setItemId(itemRecord.getProperty().getId());
itemRecord.setItemVersion(itemRecord.getProperty().getVersion());
itemRecord.setImported(true);
cache.addToCache(tmpItem);
} else if (VersionUtils.compareTo(lastVersion.getProperty().getVersion(), tmpItem.getProperty().getVersion()) < 0) {
repFactory.forceCreate(tmpItem, path);
itemRecord.setImportPath(path.toPortableString());
itemRecord.setItemId(itemRecord.getProperty().getId());
itemRecord.setRepositoryType(itemType);
itemRecord.setItemVersion(itemRecord.getProperty().getVersion());
itemRecord.setImported(true);
cache.addToCache(tmpItem);
} else {
PersistenceException e = new PersistenceException(Messages.getString("ImportItemUtil.persistenceException", //$NON-NLS-1$
tmpItem.getProperty()));
itemRecord.addError(e.getMessage());
logError(e);
}
if (tmpItem != null) {
// RelationshipItemBuilder.getInstance().addOrUpdateItem(tmpItem, true);
if (tmpItem.getState() != null) {
if (itemType != null) {
final Set<String> folders = restoreFolder.getFolders(itemType);
if (folders != null) {
for (String folderPath : folders) {
if (folderPath != null && folderPath.equals(path.toString())) {
FolderItem folderItem = repFactory.getFolderItem(ProjectManager.getInstance().getCurrentProject(), itemType, path);
if (folderItem != null) {
folderItem.getState().setDeleted(false);
while (!(folderItem.getParent() instanceof Project)) {
folderItem = (FolderItem) folderItem.getParent();
if (folderItem.getType() == FolderType.SYSTEM_FOLDER_LITERAL) {
break;
}
folderItem.getState().setDeleted(false);
}
}
break;
}
}
}
}
}
}
} catch (Exception e) {
itemRecord.addError(e.getMessage());
logError(e);
}
}
String label = itemRecord.getLabel();
EList<Resource> resources = itemRecord.getResourceSet().getResources();
Iterator<Resource> iterator = resources.iterator();
while (iterator.hasNext()) {
Resource res = iterator.next();
// it can't be unloaded just after create the item.
if (res != null && !(res instanceof ByteArrayResource)) {
res.unload();
iterator.remove();
}
}
TimeMeasure.step("importItemRecords", "Import item: " + label);
applyMigrationTasks(itemRecord, monitor);
TimeMeasure.step("importItemRecords", "applyMigrationTasks: " + label);
}
use of org.talend.commons.runtime.model.repository.ERepositoryStatus in project tdi-studio-se by Talend.
the class ImportItemUtil method checkIfLocked.
/**
* DOC hcw Comment method "checkIfLocked".
*
* @param itemRecord
* @return
* @throws PersistenceException
*/
private boolean checkIfLocked(ItemRecord itemRecord) throws PersistenceException {
Boolean lockState = cache.getItemLockState(itemRecord);
if (lockState != null) {
return lockState.booleanValue();
}
List<IRepositoryViewObject> list = cache.findObjectsByItem(itemRecord);
for (IRepositoryViewObject obj : list) {
ERepositoryStatus status = obj.getRepositoryStatus();
if (status == ERepositoryStatus.LOCK_BY_OTHER || status == ERepositoryStatus.LOCK_BY_USER) {
itemRecord.setLocked(true);
cache.setItemLockState(itemRecord, true);
return true;
}
}
cache.setItemLockState(itemRecord, false);
return false;
}
use of org.talend.commons.runtime.model.repository.ERepositoryStatus in project tdi-studio-se by Talend.
the class ImportItemUtil method checkItem.
private boolean checkItem(ItemRecord itemRecord, boolean overwrite) {
boolean result = false;
try {
Item item = itemRecord.getItem();
if (item instanceof TDQItem) {
// hide tdq first
return false;
}
ERepositoryObjectType itemType = ERepositoryObjectType.getItemType(item);
if (itemType == null) {
//$NON-NLS-1$
itemRecord.addError(Messages.getString("ImportItemUtil.unsupportItem"));
// can't import this item.
return false;
}
cache.initialize(itemType);
boolean isAllowMultipleName = (itemType == ERepositoryObjectType.SQLPATTERNS || itemType == ERepositoryObjectType.METADATA_FILE_XML);
String itemPath = null;
if (item.getState() != null) {
itemPath = item.getState().getPath();
} else {
itemRecord.addError(Messages.getString("ImportItemUtil.unsupportItem"));
return false;
}
boolean nameAvailable = true;
IRepositoryViewObject itemWithSameId = null;
IRepositoryViewObject itemWithSameName = null;
// take care, in cache it's RepositoryViewObject, not RepositoryObject
for (IRepositoryViewObject current : cache.getItemsFromRepository().get(itemType)) {
final Property property = itemRecord.getProperty();
if (property != null) {
if (property.getLabel() != null && property.getLabel().equalsIgnoreCase(current.getLabel()) && property.getId() != current.getId()) {
// repository.
if (!isAllowMultipleName || current.getPath().equals(itemPath)) {
nameAvailable = false;
}
// elements
if (!nameAvailable) {
itemWithSameName = current;
}
}
if (property.getId() != null && property.getId().equalsIgnoreCase(current.getId())) {
itemWithSameId = current;
}
}
}
itemRecord.setExistingItemWithSameId(itemWithSameId);
boolean idAvailable = itemWithSameId == null;
boolean isSystem = false;
// we do not import built in routines
if (item.eClass().equals(PropertiesPackage.eINSTANCE.getRoutineItem())) {
RoutineItem routineItem = (RoutineItem) item;
if (routineItem.isBuiltIn()) {
isSystem = true;
}
}
// we do not import system sql patterns
if (item.eClass().equals(PropertiesPackage.eINSTANCE.getSQLPatternItem())) {
SQLPatternItem sqlPatternItem = (SQLPatternItem) item;
if (sqlPatternItem.isSystem()) {
isSystem = true;
}
}
if (isSystem) {
itemRecord.addError(Messages.getString("RepositoryUtil.isSystem"));
return false;
}
if (nameAvailable) {
if (idAvailable) {
if (!isSystem) {
result = true;
}
/*
* else { itemRecord.addError(Messages.getString("RepositoryUtil.isSystemRoutine")); //$NON-NLS-1$
* }
*/
} else {
// same id but different name,no need to care overwrite cause the item will be considered as a
// different one,see bug 20445
itemRecord.setState(State.ID_EXISTED);
// if (overwrite) {
// result = true;
// } else {
// see bug 0005222: [Import items] [Errors and Warnings]
// id is already in use
result = true;
// RepositoryNode nodeWithSameId = RepositoryNodeUtilities.getRepositoryNode(itemWithSameId);
// IPath path = getPath(nodeWithSameId);
// itemRecord.addError(Messages.getString(
// "RepositoryUtil.idUsed", itemWithSameId.getLabel(), path.toOSString())); //$NON-NLS-1$
// }
}
} else {
if (idAvailable) {
// same name but different id
itemRecord.setState(State.NAME_EXISTED);
if (!isSystem && overwrite) {
// if anything system, don't replace the source item if same name.
// if not from system, can overwrite.
itemRecord.setExistingItemWithSameId(itemWithSameName);
result = true;
}
// if item is locked, cannot overwrite
if (result && overwrite && itemWithSameName != null) {
ERepositoryStatus status = itemWithSameName.getRepositoryStatus();
if (status == ERepositoryStatus.LOCK_BY_OTHER || status == ERepositoryStatus.LOCK_BY_USER) {
//$NON-NLS-1$
itemRecord.addError(Messages.getString("RepositoryUtil.itemLocked"));
return false;
}
}
} else {
// same name and same id
itemRecord.setState(State.NAME_AND_ID_EXISTED);
if (overwrite) {
result = true;
}
if (!isSystem && overwrite && !itemWithSameName.getProperty().getLabel().equals(itemWithSameId.getProperty().getLabel())) {
// if anything system, don't replace the source item if same name.
// if not from system, can overwrite.
itemRecord.setExistingItemWithSameId(itemWithSameName);
result = true;
}
}
if (!result && !isSystem) {
//$NON-NLS-1$
itemRecord.addError(Messages.getString("RepositoryUtil.nameUsed"));
}
}
if (result && overwrite && itemRecord.getState() == State.NAME_AND_ID_EXISTED) {
// if item is locked, cannot overwrite
if (checkIfLocked(itemRecord)) {
//$NON-NLS-1$
itemRecord.addError(Messages.getString("RepositoryUtil.itemLocked"));
result = false;
}
}
} catch (Exception e) {
log.error("Error when checking item :" + itemRecord.getPath(), e);
}
return result;
}
use of org.talend.commons.runtime.model.repository.ERepositoryStatus in project tdi-studio-se by Talend.
the class ImportItemWizardPage method performFinish.
public boolean performFinish() {
final List<ItemRecord> itemRecords = new ArrayList<ItemRecord>();
final List<ItemRecord> checkedItemRecords = getCheckedElements();
itemRecords.addAll(checkedItemRecords);
itemRecords.addAll(getHadoopSubrecords(itemRecords));
for (ItemRecord itemRecord : itemRecords) {
Item item = itemRecord.getProperty().getItem();
if (item instanceof JobletProcessItem) {
needToRefreshPalette = true;
}
IProxyRepositoryFactory factory = ProxyRepositoryFactory.getInstance();
if (item.getState().isLocked()) {
try {
factory.unlock(item);
} catch (PersistenceException e) {
ExceptionHandler.process(e);
} catch (LoginException e) {
ExceptionHandler.process(e);
}
}
ERepositoryStatus status = factory.getStatus(item);
if (status != null && status == ERepositoryStatus.LOCK_BY_USER) {
try {
factory.unlock(item);
} catch (PersistenceException e) {
ExceptionHandler.process(e);
} catch (LoginException e) {
ExceptionHandler.process(e);
}
}
}
try {
IRunnableWithProgress iRunnableWithProgress = new IRunnableWithProgress() {
@Override
public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
IPath destinationPath = null;
String contentType = "";
if (rNode != null && rNode.getType().equals(ENodeType.SIMPLE_FOLDER)) {
destinationPath = RepositoryNodeUtilities.getPath(rNode);
contentType = rNode.getContentType().name();
}
repositoryUtil.setErrors(false);
repositoryUtil.clear();
repositoryUtil.importItemRecords(manager, itemRecords, monitor, overwrite, destinationPath, contentType);
if (repositoryUtil.hasErrors()) {
throw new InvocationTargetException(new CoreException(new Status(IStatus.ERROR, FrameworkUtil.getBundle(this.getClass()).getSymbolicName(), //$NON-NLS-1$
"Import errors")));
}
}
};
new ProgressMonitorDialog(getShell()).run(true, true, iRunnableWithProgress);
} catch (InvocationTargetException e) {
Throwable targetException = e.getTargetException();
if (repositoryUtil.getRoutineExtModulesMap().isEmpty()) {
if (targetException instanceof CoreException) {
//$NON-NLS-1$
MessageDialog.openWarning(//$NON-NLS-1$
getShell(), //$NON-NLS-1$
Messages.getString("ImportItemWizardPage.ImportSelectedItems"), //$NON-NLS-1$
Messages.getString("ImportItemWizardPage.ErrorsOccured"));
}
}
} catch (InterruptedException e) {
//
}
ResourcesManager curManager = this.manager;
if (curManager instanceof ProviderManager) {
curManager.closeResource();
}
selectedItems = null;
itemRecords.clear();
return true;
}
use of org.talend.commons.runtime.model.repository.ERepositoryStatus in project tdi-studio-se by Talend.
the class StatusManagerSettingPage method filterRepositoryNode.
private boolean filterRepositoryNode(RepositoryNode node) {
if (node == null) {
return false;
}
if (node.isBin()) {
return false;
}
if (node.getObject() != null) {
ERepositoryStatus status = FACTORY.getStatus(node.getObject());
if (status == ERepositoryStatus.LOCK_BY_OTHER || (status == ERepositoryStatus.LOCK_BY_USER && RepositoryManager.isOpenedItemInEditor(node.getObject()))) {
return false;
}
// table
if (node.getObject() instanceof org.talend.core.model.metadata.MetadataTable) {
return false;
}
// opened items
// TODO
ERepositoryObjectType objectType = node.getObjectType();
if (objectType == ERepositoryObjectType.SQLPATTERNS || objectType == ERepositoryObjectType.ROUTINES) {
RepositoryNode systemNode = node.getParent();
if (systemNode != null) {
// for system folder
if (systemNode.getType() == ENodeType.STABLE_SYSTEM_FOLDER && systemNode.getLabel().equalsIgnoreCase(RepositoryConstants.SYSTEM_DIRECTORY)) {
return false;
}
}
}
if (node.getObject().isDeleted()) {
return false;
}
}
ERepositoryObjectType contentType = node.getContentType();
if (contentType != null) {
if (contentType == ERepositoryObjectType.REFERENCED_PROJECTS || contentType == ERepositoryObjectType.GENERATED) {
return false;
} else if (contentType == ERepositoryObjectType.SQLPATTERNS || contentType == ERepositoryObjectType.ROUTINES) {
// for system folder
if (node.getType() == ENodeType.STABLE_SYSTEM_FOLDER && node.getLabel().equalsIgnoreCase(RepositoryConstants.SYSTEM_DIRECTORY)) {
return false;
}
} else // filter tdm items
if (contentType == ERepositoryObjectType.valueOf(ERepositoryObjectType.class, "HIERARCHICAL_MAPPER")) {
return false;
}
}
// for sub folder in db connection
if (node.getType() == ENodeType.STABLE_SYSTEM_FOLDER) {
RepositoryNode parentNode = node.getParent();
if (parentNode != null) {
if (parentNode.getObjectType() == ERepositoryObjectType.METADATA_CONNECTIONS) {
return false;
}
}
}
return true;
}
Aggregations