protected List<IRepositoryViewObject> getSerializable(
Project project, String id, boolean allVersion, boolean avoidSaveProject)
throws PersistenceException {
List<IRepositoryViewObject> toReturn = new ArrayList<IRepositoryViewObject>();
if (lastFolderForItemMap.containsKey(id)) {
ERepositoryObjectType itemType = lastRepositoryTypeForItemMap.get(id);
String currentPath = lastFolderForItemMap.get(id);
Object fullFolder = getFullFolder(project, itemType, currentPath);
try {
if (fullFolder != null
&& (fullFolder instanceof FolderItem || ((IFolder) fullFolder).exists())) {
List<IRepositoryViewObject> itemsFound =
getSerializableFromFolder(
project, fullFolder, id, itemType, allVersion, false, true, avoidSaveProject);
if (!itemsFound.isEmpty()) { // add for items in recycle-bin
toReturn.addAll(itemsFound);
return toReturn;
}
}
} catch (PersistenceException e) {
// do nothing.
// if any exception happen or can't find the item, just try to look for it everywhere.
}
}
// added
for (ERepositoryObjectType repositoryObjectType :
(ERepositoryObjectType[]) ERepositoryObjectType.values()) {
if (!repositoryObjectType.isResourceItem()) {
continue;
}
Object folder = getFolder(project, repositoryObjectType);
if (folder != null) {
List<IRepositoryViewObject> itemsFound =
getSerializableFromFolder(
project,
folder,
id,
repositoryObjectType,
allVersion,
true,
true,
avoidSaveProject);
if (!itemsFound.isEmpty()) {
addToHistory(
id,
repositoryObjectType,
itemsFound.get(0).getProperty().getItem().getState().getPath());
toReturn.addAll(itemsFound);
// all items from the same id are always in the same folder
// as we shouldn't find any other item with the same id in another folder.
return toReturn;
}
}
}
return toReturn;
}
@Override
public RootContainer<String, IRepositoryViewObject> getTdqRepositoryViewObjects(
Project project, ERepositoryObjectType type, String folderName, boolean[] options)
throws PersistenceException {
String relativeFolder = folderName;
if (type != null && type.hasFolder()) {
// Compatible to the existing behavior which keep the full path relative to the project in DQ.
String baseFolder = ERepositoryObjectType.getFolderName(type);
relativeFolder = StringUtils.removeStart(relativeFolder, baseFolder);
}
return getObjectFromFolder(
project, type, relativeFolder, OPTION_ONLY_LAST_VERSION | OPTION_DYNAMIC_OBJECTS);
}
/** DOC ggu class global comment. Detailled comment */
public class ExampleDemoRepositoryNodeType {
/**
* this value is same the attribute "type" of extension point
* "org.talend.core.repository.repository_node_provider"
*/
public static final String EXAMPLE_DEMO = "EXAMPLE_DEMO"; // $NON-NLS-1$
public static ERepositoryObjectType repositoryExampleDemoType =
ERepositoryObjectType.valueOf(ERepositoryObjectType.class, EXAMPLE_DEMO);
public static final String EXTENDED_EXAMPLE_DEMO = "EXTENDED_EXAMPLE_DEMO"; // $NON-NLS-1$
public static ERepositoryObjectType repositoryExtendedExampleDemoType =
ERepositoryObjectType.valueOf(ERepositoryObjectType.class, EXTENDED_EXAMPLE_DEMO);
}
public ERepositoryObjectType getType() {
Item item = getItem();
if (item != null) {
return ERepositoryObjectType.getItemType(item);
}
return null;
}
/**
* 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-Jsdoc)
*
* @see
* org.talend.designer.codegen.ITalendSynchronizer#getRoutinesFile(org.talend.core.model.properties.RoutineItem)
*/
@Override
public IFile getRoutinesFile(Item item) throws SystemException {
try {
if (item instanceof BeanItem) {
BeanItem routineItem = (BeanItem) item;
ProjectManager projectManager = ProjectManager.getInstance();
org.talend.core.model.properties.Project project = projectManager.getProject(routineItem);
IProject iProject =
ResourcesPlugin.getWorkspace().getRoot().getProject(project.getTechnicalLabel());
String repositoryPath =
ERepositoryObjectType.getFolderName(CamelRepositoryNodeType.repositoryBeansType);
String folderPath =
RepositoryNodeUtilities.getPath(routineItem.getProperty().getId()).toString();
String fileName =
routineItem.getProperty().getLabel()
+ '_'
+ routineItem.getProperty().getVersion()
+ JavaUtils.ITEM_EXTENSION;
String path = null;
if (folderPath != null && folderPath.trim().length() > 0) {
path = repositoryPath + '/' + folderPath + '/' + fileName;
} else {
path = repositoryPath + '/' + fileName;
}
IFile file = iProject.getFile(path);
return file;
}
} catch (Exception e) {
throw new SystemException(e);
}
return null;
}
private void openedByBrowser(Item item, URL url) {
if (url == null || item == null) {
return;
}
WebBrowserEditorInput input = new WebBrowserEditorInput(url);
// add for bug TDI-21189 at 2012-6-8,that a document exist is only opened one time in studio
try {
IWorkbenchPage page = getActivePage();
IEditorReference[] iEditorReference = page.getEditorReferences();
for (IEditorReference editors : iEditorReference) {
if (WebBrowserEditor.WEB_BROWSER_EDITOR_ID.equals(editors.getId())) {
IEditorPart iEditorPart = editors.getEditor(true);
if (iEditorPart != null && iEditorPart instanceof WebBrowserEditor) {
WebBrowserEditorInput webBrowserEditorInput =
(WebBrowserEditorInput) iEditorPart.getEditorInput();
if (webBrowserEditorInput != null && url.equals(webBrowserEditorInput.getURL())) {
// page.activate(iEditorPart);
iEditorPart.init(iEditorPart.getEditorSite(), webBrowserEditorInput);
DocumentationUtil.setPartItemId(
(WebBrowserEditor) iEditorPart,
item.getProperty().getId(),
ERepositoryObjectType.getItemType(item));
return;
}
}
}
}
input.setName(item.getProperty().getLabel());
input.setToolTipText(
item.getProperty().getLabel() + " " + item.getProperty().getVersion()); // $NON-NLS-1$
IEditorPart editorPart = page.openEditor(input, WebBrowserEditor.WEB_BROWSER_EDITOR_ID);
if (editorPart != null && editorPart instanceof WebBrowserEditor) {
DocumentationUtil.setPartItemId(
(WebBrowserEditor) editorPart,
item.getProperty().getId(),
ERepositoryObjectType.getItemType(item));
}
} catch (PartInitException e) {
MessageBoxExceptionHandler.process(e);
}
}
public String getItemName() {
if (itemName == null) {
IBrandingService brandingService =
(IBrandingService) GlobalServiceRegister.getDefault().getService(IBrandingService.class);
boolean allowVerchange = brandingService.getBrandingConfiguration().isAllowChengeVersion();
ERepositoryObjectType itemType = ERepositoryObjectType.getItemType(property.getItem());
StringBuffer sb = new StringBuffer();
if (itemType != null) {
sb.append(itemType.toString());
sb.append(' ');
}
sb.append(property.getLabel());
if (allowVerchange) {
sb.append(' ');
sb.append(property.getVersion());
}
itemName = sb.toString();
}
return itemName;
}
@Override
public FolderItem getFolderItem(Project project, ERepositoryObjectType itemType, IPath path) {
if (project == null) {
// add this to fix NPE of junit for logon
return null;
}
FolderHelper folderHelper = getFolderHelper(project.getEmfProject());
String pathStr = ERepositoryObjectType.getFolderName(itemType) + IPath.SEPARATOR + path;
FolderItem folderItem = folderHelper.getFolder(pathStr);
if (folderItem == null && itemType != null) {
folderItem = folderHelper.createFolder(pathStr);
}
return folderItem;
}
@Override
public boolean isNameAvailable(
Project project, Item item, String name, List<IRepositoryViewObject>... givenList)
throws PersistenceException {
if (name == null) {
name = item.getProperty().getLabel();
}
if (item instanceof FolderItem) {
FolderHelper folderHelper = getFolderHelper(project.getEmfProject());
return !folderHelper.pathExists((FolderItem) item, name);
}
ERepositoryObjectType type = ERepositoryObjectType.getItemType(item);
if (type == ERepositoryObjectType.METADATA_CON_TABLE) {
return false;
}
boolean isAllowMultipleName =
(type == ERepositoryObjectType.SQLPATTERNS
|| type == ERepositoryObjectType.METADATA_FILE_XML);
String path = "";
if (item.getState() != null) {
path = item.getState().getPath();
}
List<IRepositoryViewObject> list;
if (givenList.length == 0) {
list = getAll(project, type, true, false);
} else {
list = givenList[0];
}
for (IRepositoryViewObject current : list) {
if (name.equalsIgnoreCase(current.getProperty().getLabel())
&& item.getProperty().getId() != current.getProperty().getId()) {
// To check SQLPattern in same path. see bug 0005038: unable to add a SQLPattern into
// repository.
if (!isAllowMultipleName
|| current.getProperty().getItem().getState().getPath().equals(path)) {
return false;
}
}
}
return true;
}
@Override
public RootContainer<String, IRepositoryViewObject> getRoutineFromProject(Project project)
throws PersistenceException {
RootContainer<String, IRepositoryViewObject> toReturn =
new RootContainer<String, IRepositoryViewObject>();
ERepositoryObjectType type = ERepositoryObjectType.ROUTINES;
if (type != null) {
IProject fsProject = ResourceUtils.getProject(project);
IFolder objectFolder =
ResourceUtils.getFolder(fsProject, ERepositoryObjectType.getFolderName(type), true);
addFolderMembers(project, type, toReturn, objectFolder, true);
saveProject(project);
}
return toReturn;
}
@Override
public boolean select(Viewer viewer, Object parentElement, Object element) {
if (element instanceof RepositoryNode) {
RepositoryNode node = (RepositoryNode) element;
if (ERepositoryObjectType.REFERENCED_PROJECTS.equals(node.getContentType())) {
return true;
}
IRepositoryNode typeNode = node.getRoot().getRootRepositoryNode(repositoryType);
if (typeNode == node) {
return true;
}
if (repositoryType.equals(node.getContentType())) {
return true;
}
return false;
}
return true; // if others, no filter
}
private void getAllVersions(
Project project, Property property, List<IRepositoryViewObject> allVersion)
throws PersistenceException {
ERepositoryObjectType itemType = ERepositoryObjectType.getItemType(property.getItem());
Object fullFolder = getFullFolder(project, itemType, property.getItem().getState().getPath());
if (fullFolder != null) {
allVersion.addAll(
getSerializableFromFolder(
project, fullFolder, property.getId(), itemType, true, false, false, true));
if (allVersion.size() == 0) {
// if no item found in current directory, look for all directory
allVersion.addAll(getAllVersion(project, property.getId(), false));
}
} else {
allVersion.addAll(getAllVersion(project, property.getId(), false));
}
if (allVersion.size() == 0 && project.getEmfProject().getReferencedProjects().size() > 0) {
String parentBranch = ProjectManager.getInstance().getMainProjectBranch(project);
for (ProjectReference refProject :
(List<ProjectReference>) project.getEmfProject().getReferencedProjects()) {
if (refProject.getBranch() != null && !parentBranch.equals(refProject.getBranch())) {
continue;
}
org.talend.core.model.properties.Project emfProject = refProject.getReferencedProject();
getAllVersions(new Project(emfProject), property, allVersion);
if (allVersion.size() > 0) {
break;
}
}
}
// MOD mzhao Temporary return original object. In this case, the object hasn't been updated from
// svn server.
if (allVersion.size() == 0) {
allVersion.add(new RepositoryViewObject(property));
}
}
@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;
}
public ERepositoryObjectType getRepositoryType() {
if (repositoryType == null) {
repositoryType = ERepositoryObjectType.getItemType(property.getItem());
}
return repositoryType;
}
@Override
public String getLabel() {
return type.toString();
}
public TypeNode(ERepositoryObjectType type) {
super(type.toString());
this.type = type;
}
@Override
public ERepositoryObjectType getRepositoryObjectType(Item item) {
return item instanceof ContextItem ? ERepositoryObjectType.getType("JOB_DOC_EXT") : null;
}
protected void createSystemRoutines() throws PersistenceException {
ERepositoryObjectType routinesType = ERepositoryObjectType.ROUTINES;
if (routinesType == null) {
return; // don't load, nothing to do
}
ILibrariesService service = null;
if (!GlobalServiceRegister.getDefault().isServiceRegistered(ILibrariesService.class)) {
return;
}
service =
(ILibrariesService) GlobalServiceRegister.getDefault().getService(ILibrariesService.class);
Project project = getRepositoryContext().getProject();
FolderHelper folderHelper = getFolderHelper(project.getEmfProject());
List<URL> routines = service.getSystemRoutines();
Path path = new Path(RepositoryConstants.SYSTEM_DIRECTORY);
// will automatically set the children folders
IPath systemRoutinePath = new Path(ERepositoryObjectType.getFolderName(routinesType));
systemRoutinePath = systemRoutinePath.append(RepositoryConstants.SYSTEM_DIRECTORY);
FolderItem folderItem = folderHelper.getFolder(systemRoutinePath);
if (folderItem == null) {
folderItem = folderHelper.createFolder(systemRoutinePath.toString());
}
IPath systemRoutineApiPath = new Path(ERepositoryObjectType.getFolderName(routinesType));
systemRoutineApiPath =
systemRoutinePath.append(RepositoryConstants.SYSTEM_DIRECTORY).append("api");
FolderItem folderItemApi = folderHelper.getFolder(systemRoutineApiPath);
if (folderItemApi == null) {
folderItemApi = folderHelper.createFolder(systemRoutineApiPath.toString());
}
List<IRepositoryViewObject> repositoryObjects = getAll(project, routinesType, false, false);
Map<String, List<LibraryInfo>> routineAndJars = coreSerivce.getRoutineAndJars();
for (URL url : routines) {
String[] fragments = url.toString().split("/"); // $NON-NLS-1$
String label = fragments[fragments.length - 1];
String[] tmp = label.split("\\."); // $NON-NLS-1$
String routineLabel = tmp[0];
if (routineLabel.equals(coreSerivce.getTemplateString())) {
continue;
}
RoutineItem existingItem = null;
for (IRepositoryViewObject object : repositoryObjects) {
if (object.getLabel().equals(routineLabel)
&& object.getProperty().getItem() instanceof RoutineItem) {
existingItem = (RoutineItem) object.getProperty().getItem();
break;
}
}
if (existingItem == null) {
createRoutine(
url,
path,
routineLabel,
routineAndJars != null ? routineAndJars.get(routineLabel) : null);
} else {
updateRoutine(url, existingItem);
existingItem.setParent(folderItem);
}
}
}
/** DOC ycbai class global comment. Detailled comment */
public class HDFSRepositoryNodeType {
public static ERepositoryObjectType HDFS =
ERepositoryObjectType.valueOf(ERepositoryObjectType.class, "HDFS"); // $NON-NLS-1$
}
protected void createSystemSQLPatterns() throws PersistenceException {
ERepositoryObjectType sqlpatternsType = ERepositoryObjectType.SQLPATTERNS;
if (sqlpatternsType == null) {
return; // don't load, nothing to do
}
ILibrariesService service = null;
if (!GlobalServiceRegister.getDefault().isServiceRegistered(ILibrariesService.class)) {
return;
}
service =
(ILibrariesService) GlobalServiceRegister.getDefault().getService(ILibrariesService.class);
Project project = getRepositoryContext().getProject();
FolderHelper folderHelper = getFolderHelper(project.getEmfProject());
// will automatically set the children folders
// FolderItem folderItem = folderHelper.getFolder("sqlPatterns/system");
// if (folderItem == null) {
// folderItem = folderHelper.createFolder("sqlPatterns/system"); //$NON-NLS-1$
// }
List<URL> routines = service.getSystemSQLPatterns();
List<IRepositoryViewObject> repositoryObjects = getAll(project, sqlpatternsType, false, false);
for (URL url : routines) {
String[] fragments = url.toString().split("/"); // $NON-NLS-1$
String label = fragments[fragments.length - 1];
String[] tmp = label.split("\\."); // $NON-NLS-1$
Path relativePath = new Path(url.getFile());
// for instance: categoryName is Teradata; fileName is
// Loadfile.sqlpattern
String fileName = relativePath.segment(relativePath.segmentCount() - 1);
String categoryName = relativePath.segment(relativePath.segmentCount() - 2);
tmp = fileName.split("\\."); // $NON-NLS-1$
String sqlPatternLabel = tmp[0];
SQLPatternItem existingItem = null;
for (IRepositoryViewObject object : repositoryObjects) {
if (object.getLabel().equals(sqlPatternLabel)
&& object.getProperty().getItem() instanceof SQLPatternItem
&& ((SQLPatternItem) object.getProperty().getItem())
.getEltName()
.equals(categoryName)) {
existingItem = (SQLPatternItem) object.getProperty().getItem();
break;
}
}
// check the folder for categoryName,system,UserDefined
// set the item's relative path in the repository view
IPath categoryPath = new Path(categoryName);
IPath systemPath = categoryPath.append(RepositoryConstants.SYSTEM_DIRECTORY);
IPath userPath = categoryPath.append(RepositoryConstants.USER_DEFINED);
IPath parentPath = new Path(ERepositoryObjectType.getFolderName(sqlpatternsType));
if (folderHelper.getFolder(parentPath.append(categoryPath)) == null) {
createFolder(
getRepositoryContext().getProject(),
sqlpatternsType,
new Path(""),
categoryPath //$NON-NLS-1$
.lastSegment());
}
FolderItem systemFolder = folderHelper.getFolder(parentPath.append(systemPath));
if (systemFolder == null) {
Folder folder =
createFolder(
getRepositoryContext().getProject(),
sqlpatternsType,
categoryPath,
systemPath.lastSegment());
((FolderItem) folder.getProperty().getItem()).setType(FolderType.FOLDER_LITERAL);
}
if (folderHelper.getFolder(parentPath.append(userPath)) == null) {
Folder folder =
createFolder(
getRepositoryContext().getProject(),
sqlpatternsType,
categoryPath,
userPath.lastSegment());
((FolderItem) folder.getProperty().getItem()).setType(FolderType.FOLDER_LITERAL);
}
//
if (existingItem == null) {
createSQLPattern(url, sqlPatternLabel, categoryName);
} else {
updateSQLPattern(url, existingItem);
existingItem.setParent(systemFolder);
}
}
}
