edu.harvard.med.screensaver.io.libraries.WellDeprecator.java Source code

Introduction

Here is the source code for edu.harvard.med.screensaver.io.libraries.WellDeprecator.java

Source

// $HeadURL$
// $Id$
//
// Copyright  2006, 2010, 2011, 2012 by the President and Fellows of Harvard College.
//
// Screensaver is an open-source project developed by the ICCB-L and NSRB labs
// at Harvard Medical School. This software is distributed under the terms of
// the GNU General Public License.

package edu.harvard.med.screensaver.io.libraries;

import java.io.File;
import java.io.IOException;
import java.util.HashSet;
import java.util.Set;

import org.apache.commons.cli.OptionBuilder;
import org.apache.commons.cli.ParseException;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.LineIterator;
import org.apache.log4j.Logger;
import org.joda.time.LocalDate;
import org.joda.time.format.DateTimeFormat;
import org.springframework.transaction.annotation.Transactional;

import edu.harvard.med.screensaver.db.DAOTransaction;
import edu.harvard.med.screensaver.db.DAOTransactionRollbackException;
import edu.harvard.med.screensaver.db.GenericEntityDAO;
import edu.harvard.med.screensaver.db.LibrariesDAO;
import edu.harvard.med.screensaver.io.CommandLineApplication;
import edu.harvard.med.screensaver.io.FatalParseException;
import edu.harvard.med.screensaver.model.activities.AdministrativeActivity;
import edu.harvard.med.screensaver.model.activities.AdministrativeActivityType;
import edu.harvard.med.screensaver.model.libraries.Well;
import edu.harvard.med.screensaver.model.libraries.WellKey;
import edu.harvard.med.screensaver.model.users.AdministratorUser;
import edu.harvard.med.screensaver.model.users.ScreensaverUser;

/**
 * Command-line application that deprecates a set of wells
 *
 * @author <a mailto="andrew_tolopko@hms.harvard.edu">Andrew Tolopko</a>
 */
public class WellDeprecator {
    // static members

    private static Logger log = Logger.getLogger(WellDeprecator.class);

    @SuppressWarnings("static-access")
    public static void main(String[] args) {
        final CommandLineApplication app = new CommandLineApplication(args);
        app.addCommandLineOption(
                OptionBuilder.hasArg().isRequired().withArgName("admin user ID").withLongOpt("admin-approved-by")
                        .withDescription("user ID of administrator that approved this well deprecation activity")
                        .create("aa"));
        app.addCommandLineOption(
                OptionBuilder.hasArg().isRequired().withArgName("yyyy-mm-dd").withLongOpt("approval-date")
                        .withDescription("date this well deprecation activity was approved").create("d"));
        app.addCommandLineOption(
                OptionBuilder.hasArg().isRequired().withArgName("text").withLongOpt("comments").create("c"));
        app.addCommandLineOption(OptionBuilder.hasArg().isRequired().withArgName("file").withLongOpt("input-file")
                .withDescription("workbook file containing list of wells to be deprecated").create("f"));
        app.processOptions(true, true);

        final GenericEntityDAO dao = (GenericEntityDAO) app.getSpringBean("genericEntityDao");

        dao.doInTransaction(new DAOTransaction() {
            public void runTransaction() {
                try {
                    int size = updateWells(app, dao);
                    System.out.println("WellDeprecator read in and added comments for " + size + " wells.");
                } catch (Exception e) {
                    e.printStackTrace();
                    log.error(e.toString());
                    System.exit(1);
                }
            }
        });

    }

    @Transactional
    private static int updateWells(CommandLineApplication app, GenericEntityDAO dao)
            throws ParseException, IOException {
        String comments = app.getCommandLineOptionValue("c");
        Integer approvedByAdminId = app.getCommandLineOptionValue("aa", Integer.class);
        LocalDate dateApproved = app.getCommandLineOptionValue("d",
                DateTimeFormat.forPattern(CommandLineApplication.DEFAULT_DATE_PATTERN)).toLocalDate();

        AdministratorUser performedBy = app.findAdministratorUser();
        AdministratorUser approvedBy = dao.findEntityById(AdministratorUser.class, approvedByAdminId);
        if (approvedBy == null) {
            throw new IllegalArgumentException("no administrator user found with User ID=" + approvedByAdminId);
        }

        final AdministrativeActivity activity = new AdministrativeActivity(performedBy, approvedBy, dateApproved,
                AdministrativeActivityType.WELL_DEPRECATION);
        activity.setComments(comments);
        final int[] _sizeRead = new int[1];
        final LibrariesDAO librariesDao = (LibrariesDAO) app.getSpringBean("librariesDao");
        final Set<WellKey> wellKeys = readWellsFromFile(app);
        for (WellKey wellKey : wellKeys) {
            Well well = librariesDao.findWell(wellKey);
            if (well == null) {
                throw new DAOTransactionRollbackException("no such well " + wellKey);
            } else {
                if (well.getDeprecationActivity() != null) {
                    throw new DAOTransactionRollbackException("well " + wellKey + " is already deprecated");
                }
                well.setDeprecationActivity(activity);
            }
        }
        log.info("WellDeprecator read in and added comments for " + wellKeys.size() + " wells.");
        return wellKeys.size();
    }

    //  private static AdministratorUser findPerformedByAdminUser(String performedByEcommonsId,
    //                                                            GenericEntityDAO dao)
    //    throws Exception
    //  {
    //    AdministratorUser admin =
    //      dao.findEntityByProperty(AdministratorUser.class,
    //                               "ECommonsId",
    //                               performedByEcommonsId,
    //                               false,
    //                               ScreensaverUser.activitiesPerformed.castToSubtype(AdministratorUser.class));
    //
    //    if (admin == null) {
    //      throw new Exception("no such user with eCommons ID " + performedByEcommonsId);
    //    }
    //    return admin;
    //  }

    private static Set<WellKey> readWellsFromFile(CommandLineApplication app) throws IOException, ParseException {
        Set<WellKey> wellKeys = new HashSet<WellKey>();
        LineIterator lines = FileUtils.lineIterator(new File(app.getCommandLineOptionValue("f")), null);
        while (lines.hasNext()) {
            String line = lines.nextLine().trim();
            if (line.length() > 0) {
                try {
                    wellKeys.add(new WellKey(line));
                } catch (Exception e) {
                    throw new FatalParseException("invalid well key '" + line + "': " + e);
                }
            }
        }
        return wellKeys;
    }
}