示例#1
0
  private void updateRoutine(URL url, RoutineItem item) throws PersistenceException {
    InputStream stream = null;
    try {
      stream = url.openStream();
      byte[] innerContent = new byte[stream.available()];
      stream.read(innerContent);
      stream.close();

      byte[] currentContent = item.getContent().getInnerContent();

      if (!Arrays.equals(innerContent, currentContent)) {
        item.getContent().setInnerContent(innerContent);
        Project project = getRepositoryContext().getProject();
        save(project, item);
      }

    } catch (IOException ioe) {
      if (stream != null) {
        try {
          stream.close();
        } catch (IOException e) {
          throw new PersistenceException(ioe);
        }
      }
      throw new PersistenceException(ioe);
    }
  }
示例#2
0
  /**
   * DOC smallet Comment method "createRoutine".
   *
   * @param url
   * @throws PersistenceException
   */
  private void createRoutine(URL url, IPath path, String label, List<LibraryInfo> neededJars)
      throws PersistenceException {
    if (url == null) {
      throw new IllegalArgumentException();
    }
    InputStream stream = null;
    try {
      Property property = PropertiesFactory.eINSTANCE.createProperty();
      property.setId(getNextId());
      property.setLabel(label);

      ByteArray byteArray = PropertiesFactory.eINSTANCE.createByteArray();
      stream = url.openStream();
      byte[] innerContent = new byte[stream.available()];
      stream.read(innerContent);
      stream.close();
      byteArray.setInnerContent(innerContent);

      // String basePath = System.getProperty("user.dir") + File.separator + "plugins";

      RoutineItem routineItem = PropertiesFactory.eINSTANCE.createRoutineItem();
      routineItem.setProperty(property);
      routineItem.setContent(byteArray);
      routineItem.setBuiltIn(true);
      if (neededJars != null) {
        for (LibraryInfo jar : neededJars) {
          IMPORTType type = ComponentFactory.eINSTANCE.createIMPORTType();
          type.setMESSAGE("");
          type.setNAME(label);
          type.setREQUIRED(true);
          type.setMODULE(jar.getLibName());
          type.setBundleID(jar.getBundleId());
          routineItem.getImports().add(type);
        }
      }

      if (!routineItem.getProperty().getLabel().equals(coreSerivce.getTemplateString())) {
        create(getRepositoryContext().getProject(), routineItem, path, true);
      }
    } catch (IOException ioe) {
      if (stream != null) {
        try {
          stream.close();
        } catch (IOException e) {
          throw new PersistenceException(ioe);
        }
      }
      throw new PersistenceException(ioe);
    }
  }
示例#3
0
  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);
      }
    }
  }