Changeset 551

Timestamp:

Jan 24, 2008, 4:52:09 PM (13 years ago)

Author:

Martin Svensson

Message:

References #89 Start to insert illumina items with the installation plug-in

File:

• trunk/net/sf/basedb/illumina/src/net/sf/basedb/illumina/install/Install.java (modified) (9 diffs)

trunk/net/sf/basedb/illumina/src/net/sf/basedb/illumina/install/Install.java

@@ -25 +25 @@
 package net.sf.basedb.illumina.install;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
 import java.util.Collections;
+import java.util.EnumSet;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
 import java.util.Set;
 
 import net.sf.basedb.core.BaseException;
+import net.sf.basedb.core.BooleanParameterType;
+import net.sf.basedb.core.DataFileType;
+import net.sf.basedb.core.DbControl;
+import net.sf.basedb.core.InvalidDataException;
 import net.sf.basedb.core.Item;
+import net.sf.basedb.core.ItemAlreadyExistsException;
+import net.sf.basedb.core.Permission;
+import net.sf.basedb.core.Platform;
+import net.sf.basedb.core.PlatformVariant;
 import net.sf.basedb.core.PluginDefinition;
+import net.sf.basedb.core.PluginParameter;
 import net.sf.basedb.core.ProgressReporter;
+import net.sf.basedb.core.RawDataType;
+import net.sf.basedb.core.RawDataTypes;
 import net.sf.basedb.core.RequestInformation;
+import net.sf.basedb.core.StringParameterType;
 import net.sf.basedb.core.plugin.About;
 import net.sf.basedb.core.plugin.AboutImpl;
@@ -38 +57 @@
 import net.sf.basedb.core.plugin.GuiContext;
 import net.sf.basedb.core.plugin.InteractivePlugin;
+import net.sf.basedb.core.plugin.Permissions;
 import net.sf.basedb.core.plugin.Plugin;
 import net.sf.basedb.core.plugin.Request;
@@ -48 +68 @@
   
   <ul>
-  <li>Create the <code>Illumina</code> platform with two
-    variants <code>Expression</code> and <code>Snip</code>
+  <li>Create the <code>Illumina</code> platform with three
+    variants <code>Expression1</code>, <code>Expression2</code> 
+    and <code>SNP</code>.
     
   <li>Register the following data file types:
-  
-  <li>Add raw data types
+    <ul>
+      <li>BGX
+      <li>ScanData
+      <li>SNP-files...??  
   
   <li>Add reporter annotations
@@ -64 +87 @@
   implements InteractivePlugin
 {
-
   private static final About about = new AboutImpl(
     "Illumina plug-ins installer", 
@@ -80 +102 @@
   private static final Set<GuiContext> guiContexts = 
     Collections.singleton(new GuiContext(Item.PLUGINDEFINITION, GuiContext.Type.ITEM));
-  
+
+  private RequestInformation configureJob = null;
+  
+  private static final Set<Permissions> permissions = new HashSet<Permissions>();
+  
+  private static final PluginParameter<Boolean> installSnpVariantParameter = new PluginParameter<Boolean>
+    (
+      "installSnp",
+      "Install SNP variant",
+      "The SNP variant of Illumina should be installed?",
+      new BooleanParameterType(true, true)
+    );    
+  private static final PluginParameter<Boolean> installExp1VariantParameter = new PluginParameter<Boolean>
+  (
+    "installExp1",
+    "Install Expression1 variant",
+    "The Expression1 variant of Illumina should be installed?",
+    new BooleanParameterType(true, true)
+  );  
+  private static final PluginParameter<Boolean> installExp2VariantParameter = new PluginParameter<Boolean>
+  (
+    "installExp2",
+    "Install Expression2 variant",
+    "The Expression2 variant of Illumina should be installed?",
+    new BooleanParameterType(true, true)
+  );
+      
+  public static final String SKIP_OPTION = "skip";
+  public static final String ABORT_OPTION = "abort";
+  
+  private static final String BGX_FILEYTPE_EXTENSION = "bgx";
+  private static final String SCANDATA_FILETYPE_EXTENSION = "";
+  private static final String SNP_FILETYPE_EXTENSION = "";
+  
+  private static final PluginParameter<String> alreadyInstalledErrorParameter = new PluginParameter<String>(
+    "alreadyInstalledError",
+    "Platform or any of the selected variants is already installed",
+    "How to situations where the platform or any of the selected variants " +
+    "already exists in the database." +
+    "If not specified, default value will be used.\n\n" +
+    "abort = Abort the installation, nothing will be created.\n" +
+    "skip = Installation of the already existing item will be skipped " +
+    "and the installation tries to proceed with rest of the items.",
+    new StringParameterType(255, SKIP_OPTION, true, 1, 0, 0, 
+      Arrays.asList( new String[] { ABORT_OPTION, SKIP_OPTION}))
+  );
   
   public Install()
@@ -94 +161 @@
   }
   @Override
+  public Collection<Permissions> getPermissions()
+  {
+    if (permissions.size() == 0)
+    {
+      permissions.add(new Permissions(Item.PLATFORM, null, EnumSet.of(Permission.CREATE)));
+      permissions.add(new Permissions(Item.PLATFORM, null, EnumSet.of(Permission.WRITE)));
+      permissions.add(new Permissions(Item.PLATFORMVARIANT, null, EnumSet.of(Permission.CREATE)));
+      permissions.add(new Permissions(Item.DATAFILETYPE, null, EnumSet.of(Permission.CREATE)));
+    }
+    return permissions;
+  }
+  @Override
   public boolean supportsConfigurations()
   {
@@ -110 +189 @@
   {
     String command = request.getCommand();
-    response.setDone("Nothing has been done! Only testing");
+    if (command.equals(Request.COMMAND_EXECUTE))
+    {
+      try
+      {
+        boolean installSnp = (Boolean)job.getValue("installSnp");
+        boolean installExp1 = (Boolean)job.getValue("installExp1");
+        boolean installExp2 = (Boolean)job.getValue("installExp2");
+        String alreadyExistingItem = (String)job.getValue("alreadyInstalledError");
+        
+        HashSet<Integer> expressionTypes = new HashSet<Integer>();
+        if (installExp1) expressionTypes.add(1);
+        if (installExp2) expressionTypes.add(2);
+        
+        installIlluminaItems(installSnp, expressionTypes, alreadyExistingItem.equals(SKIP_OPTION));
+      }
+      catch(Throwable ex)
+      {
+        response.setError(ex.getMessage(), Arrays.asList(ex));
+        return;
+      }
+      response.setDone("Illumina items were installed successfully");
+    }
+    else
+    {
+      response.setError("Unknown command: " + command, null);
+    }   
   }
   // -------------------------------------------
@@ -141 +245 @@
   public void configure(GuiContext context, Request request, Response response) 
   {
-    response.setDone("Nothing really. Just testing");
+    String command = request.getCommand();
+    if (command.equals(Request.COMMAND_CONFIGURE_JOB))
+    {
+      List<Throwable> errors = validateRequestParameters(
+          getConfigureJobParameters().getParameters(), 
+          request);
+      
+      if (errors != null)
+      {
+        response.setError(errors.size() + " invalid parameters were found in the request", errors);
+        return;
+      }
+      storeValue(job, request, alreadyInstalledErrorParameter);
+      storeValue(job, request, installExp1VariantParameter);
+      storeValue(job, request, installExp2VariantParameter);
+      storeValue(job, request, installSnpVariantParameter);
+      
+      response.setDone("The job configuration is complete.");
+    }
+    else
+    {
+      response.setError("Unknown command: " + command, null);
+    }
   }
 
@@ -155 +281 @@
   }
   // -------------------------------------------
+  
+  /**
+    Creates items that are required when working with the Illumina platform in BASE.
+    The items get the following external ids:
+    <ul>
+      
+    This method gives options on which platform variants to create and how already 
+    existing items should be handled.
+    @param installSNP TRUE if the SNP variant should be created, FALSE otherwise
+    @param expressionTypes A set of numbers. A expression variant will be created for each object in the set
+      and the number itself represent the number of strip(s) in an array of the variant to create.
+    @param ignoreExistingItems TRUE if items already existing should be ignored and the rest should be installed.
+       FALSE if NO items should be created when there is one or more already existing in BASE.
+    @throws ItemAlreadyExistsException If ignoreInstalledItems = FALSE and one of the
+   */
+  public void installIlluminaItems(boolean installSNP, HashSet<Integer> expressionTypes, boolean ignoreExistingItems)
+    throws ItemAlreadyExistsException
+  {
+    DbControl dc = null;
+    int largestNumOfStrips = 0;
+    //external ids.
+    String illuminaPlatformExternalId = "illumina";
+    String snpVariantExternalId = "illumina.snp";
+    String expExternalIdPrefix = "illumina.exp";
+    String scandataFileTypePrefix = "illlumina.scandata.";
+    String bgxFileTypeId = "illumina.bgx";
+    
+    Iterator<Integer> expressionTypeIterator = expressionTypes.iterator();
+    while(expressionTypeIterator.hasNext())
+    {
+      int next = expressionTypeIterator.next(); 
+      largestNumOfStrips = largestNumOfStrips < next ? next : largestNumOfStrips; 
+    }
+    
+    try
+    {
+      dc = sc.newDbControl();
+  
+      List<DataFileType> dataFileTypes = new ArrayList<DataFileType>();
+      dataFileTypes.add(createDataFileType(dc, bgxFileTypeId, "BGX file", Item.ARRAYDESIGN, BGX_FILEYTPE_EXTENSION, ignoreExistingItems));
+
+      for (int i = 1; i <= largestNumOfStrips; i++ )
+      {
+        String name = "Scandata filetype" + i;        
+        dataFileTypes.add(createDataFileType(dc, scandataFileTypePrefix + i, name, Item.RAWBIOASSAY, SCANDATA_FILETYPE_EXTENSION, ignoreExistingItems));
+      }
+      //TODO Create data file type for SNP filer.
+  
+//
+//      Platform illuminaPlatform = createPlatform(dc, illuminaPlatformExternalId, "Illumina", ignoreExistingItems);
+//            
+//      List<PlatformVariant> platformVariants = new ArrayList<PlatformVariant>();      
+//      String namePrefix = "Illumina expression";
+//      for (int type : expressionTypes)
+//      {
+//        PlatformVariant pfv = createPlatformVariant(dc, expExternalIdPrefix + type, 
+//            illuminaPlatform, RawDataTypes.getRawDataType("illumina.scandata"), ignoreExistingItems);
+//        pfv.setName(namePrefix + type);
+//        pfv.setDescription("Platform variant to use with Illumina expression");
+//        //TODO Add data file types to the expression variants.
+//        platformVariants.add(pfv);        
+//      }
+//      if (installSNP)
+//      {
+//        PlatformVariant pfv = createPlatformVariant(dc, snpVariantExternalId, "Illumina SNP", illuminaPlatform, 2, ignoreExistingItems);
+//        pfv.setName("Illumina SNP");
+//        pfv.setDescription("Platform variant to be used for Illumina SNP data.");
+//        //TODO Add data file types to the SNP variant.
+//        platformVariants.add(pfv);        
+//      }
+      
+      dc.commit();
+    }
+    finally
+    {
+      if (dc != null) 
+      {
+        dc.close();
+      }
+    }
+  }
 
   private RequestInformation getConfigureJobParameters()
   {
-    return new RequestInformation
-    (
-      Request.COMMAND_CONFIGURE_JOB,
-      "Select Installation options",
-      about.getDescription(),
-      null
-    );
-
-  }
-  
+    if (configureJob == null)
+    {
+      List<PluginParameter<?>> parameters = new ArrayList<PluginParameter<?>>();
+      parameters.add(installSnpVariantParameter);
+      parameters.add(installExp1VariantParameter);
+      parameters.add(installExp2VariantParameter);
+      parameters.add(alreadyInstalledErrorParameter);
+      
+      configureJob = new RequestInformation
+        (
+          Request.COMMAND_CONFIGURE_JOB,
+          "Select installation options",
+          "Set which parts to install and " +
+          "how to act if items already exists.",
+          parameters
+        ); 
+    }
+    return configureJob;
+  }
+  
+  private DataFileType createDataFileType(DbControl dc, String externalId, String name, 
+        Item itemType, String extension, boolean ignoreExistingItem)
+    throws ItemAlreadyExistsException
+  {
+  
+    DataFileType dft = null;
+    try
+    {
+      dft = DataFileType.getNew(dc, externalId, itemType);
+      dc.saveItem(dft);
+      dft.setName(name);
+      dft.setExtension(extension);
+    }
+    catch (ItemAlreadyExistsException iex)
+    {
+      if (!ignoreExistingItem)
+      {
+        throw iex;
+      }
+      else
+      {
+        dft = DataFileType.getByExternalId(dc, externalId);
+        if (dft.getExtension() != extension) throw new InvalidDataException(dft.getName() + " has invalid extension");
+        if (dft.getItemType() != itemType) throw new InvalidDataException(dft.getName() + " has invalid item type");
+      }
+    }
+    return dft;
+  }
+  
+  private Platform createPlatform(DbControl dc, String externalId, String name, boolean ignoreExistingItem)
+  {
+    Platform platform = null;
+    try
+    {
+      platform = Platform.getNew(dc, externalId, null);
+      //TODO More property to set?
+      dc.saveItem(platform);
+      platform.setName(name);
+    }
+    catch (ItemAlreadyExistsException iex)
+    {
+      if (!ignoreExistingItem)
+      {
+        throw iex;
+      }
+      else
+      {
+        platform = Platform.getByExternalId(dc, externalId);
+        //TODO Check that existing platform can be used with the rest of the items.
+      }
+    }
+    return platform;
+  }
+  
+  /*
+    Creates variants associated with a raw data type 
+   */
+  private PlatformVariant createPlatformVariant(DbControl dc, String extId,
+      Platform illuminaPlatform, RawDataType rawDataType, boolean ignoreExistingItem)
+  {
+    PlatformVariant variant = null;
+    try
+    {
+      variant = PlatformVariant.getNew(dc, illuminaPlatform, extId, rawDataType);
+      dc.saveItem(variant);     
+    }
+    catch (ItemAlreadyExistsException iex)
+    {
+      if (!ignoreExistingItem)
+      {
+        throw iex;
+      }
+      else
+      {
+        variant = PlatformVariant.getByExternalId(dc, extId);
+        if (variant.isFileOnly()) 
+          throw new InvalidDataException ("Platform variant " + variant.getName() + " exists but is not file-only");
+        if (!variant.getRawDataType().equals(rawDataType)) 
+          throw new InvalidDataException ("Platform variant " + variant.getName() + " exists but has not raw data type: " + rawDataType);
+        if (!variant.getPlatform().equals(illuminaPlatform)) 
+          throw new InvalidDataException ("Platform variant " + variant.getName() + " exists but has not platform: " + illuminaPlatform);
+      }
+    }
+    return null;
+  }
+
+  /*
+    Creates file-only platform variants
+   */
+  private PlatformVariant createPlatformVariant(DbControl dc,
+      String snpVariantExternalId, String name, Platform illuminaPlatform,
+      int channels, boolean ignoreExistingItems)
+  {
+    // TODO Auto-generated method stub
+    return null;
+  }
 }
-
-
-