Example #1
0
  private void deleteItems(Context c, String mapFile) throws Exception {
    System.out.println("Deleting items listed in mapfile: " + mapFile);

    // read in the mapfile
    Map<String, String> myhash = readMapFile(mapFile);

    // now delete everything that appeared in the mapFile
    Iterator<String> i = myhash.keySet().iterator();

    while (i.hasNext()) {
      String itemID = myhash.get(i.next());

      if (itemID.indexOf('/') != -1) {
        String myhandle = itemID;
        System.out.println("Deleting item " + myhandle);
        deleteItem(c, myhandle);
      } else {
        // it's an ID
        Item myitem = Item.find(c, Integer.parseInt(itemID));
        System.out.println("Deleting item " + itemID);
        deleteItem(c, myitem);
      }
      c.clearCache();
    }
  }
Example #2
0
  private void replaceItems(
      Context c, Collection[] mycollections, String sourceDir, String mapFile, boolean template)
      throws Exception {
    // verify the source directory
    File d = new java.io.File(sourceDir);

    if (d == null || !d.isDirectory()) {
      System.out.println("Error, cannot open source directory " + sourceDir);
      System.exit(1);
    }

    // read in HashMap first, to get list of handles & source dirs
    Map<String, String> myHash = readMapFile(mapFile);

    // for each handle, re-import the item, discard the new handle
    // and re-assign the old handle
    for (Map.Entry<String, String> mapEntry : myHash.entrySet()) {
      // get the old handle
      String newItemName = mapEntry.getKey();
      String oldHandle = mapEntry.getValue();

      Item oldItem = null;

      if (oldHandle.indexOf('/') != -1) {
        System.out.println("\tReplacing:  " + oldHandle);

        // add new item, locate old one
        oldItem = (Item) HandleManager.resolveToObject(c, oldHandle);
      } else {
        oldItem = Item.find(c, Integer.parseInt(oldHandle));
      }

      /* Rather than exposing public item methods to change handles --
       * two handles can't exist at the same time due to key constraints
       * so would require temp handle being stored, old being copied to new and
       * new being copied to old, all a bit messy -- a handle file is written to
       * the import directory containing the old handle, the existing item is
       * deleted and then the import runs as though it were loading an item which
       * had already been assigned a handle (so a new handle is not even assigned).
       * As a commit does not occur until after a successful add, it is safe to
       * do a delete as any error results in an aborted transaction without harming
       * the original item */
      File handleFile =
          new File(sourceDir + File.separatorChar + newItemName + File.separatorChar + "handle");
      PrintWriter handleOut = new PrintWriter(new FileWriter(handleFile, true));

      if (handleOut == null) {
        throw new Exception("can't open handle file: " + handleFile.getCanonicalPath());
      }

      handleOut.println(oldHandle);
      handleOut.close();

      deleteItem(c, oldItem);
      addItem(c, mycollections, sourceDir, newItemName, null, template);
      c.clearCache();
    }
  }
Example #3
0
  private void addItems(
      Context c, Collection[] mycollections, String sourceDir, String mapFile, boolean template)
      throws Exception {
    Map<String, String> skipItems =
        new HashMap<String, String>(); // set of items to skip if in 'resume'
    // mode

    System.out.println("Adding items from directory: " + sourceDir);
    System.out.println("Generating mapfile: " + mapFile);

    // create the mapfile
    File outFile = null;

    if (!isTest) {
      // get the directory names of items to skip (will be in keys of
      // hash)
      if (isResume) {
        skipItems = readMapFile(mapFile);
      }

      // sneaky isResume == true means open file in append mode
      outFile = new File(mapFile);
      mapOut = new PrintWriter(new FileWriter(outFile, isResume));

      if (mapOut == null) {
        throw new Exception("can't open mapfile: " + mapFile);
      }
    }

    // open and process the source directory
    File d = new java.io.File(sourceDir);

    if (d == null || !d.isDirectory()) {
      System.out.println("Error, cannot open source directory " + sourceDir);
      System.exit(1);
    }

    String[] dircontents = d.list(directoryFilter);

    Arrays.sort(dircontents);

    for (int i = 0; i < dircontents.length; i++) {
      if (skipItems.containsKey(dircontents[i])) {
        System.out.println("Skipping import of " + dircontents[i]);
      } else {
        addItem(c, mycollections, sourceDir, dircontents[i], mapOut, template);
        System.out.println(i + " " + dircontents[i]);
        c.clearCache();
      }
    }
  }