opensource/galaxy
3
0
Fork 0
mirror of https://github.com/galaxyproject/galaxy.git synced 2026-09-24 16:30:27 +08:00
Code Issues Packages Projects Releases Wiki Activity

merge

Browse Source
This commit is contained in:
Enis Afgan
2009-11-17 16:16:26 -05:00
parent 1bb086c83d c73610de9d
commit 05fb70f48d
61 changed files with 3054 additions and 2255 deletions
Download Patch File Download Diff File Expand all files Collapse all files
datatypes_conf.xml.sample
+221 -208
View File
@@ -1,211 +1,224 @@
<?xml version="1.0"?>
<datatypes>
<registration converters_path="lib/galaxy/datatypes/converters">
<datatype extension="ab1" type="galaxy.datatypes.images:Ab1" mimetype="application/octet-stream" display_in_upload="true"/>
<datatype extension="axt" type="galaxy.datatypes.sequence:Axt" display_in_upload="true"/>
<datatype extension="bam" type="galaxy.datatypes.images:Bam" mimetype="application/octet-stream"/>
<datatype extension="bed" type="galaxy.datatypes.interval:Bed" display_in_upload="true">
<converter file="bed_to_gff_converter.xml" target_datatype="gff"/>
<converter file="interval_to_coverage.xml" target_datatype="coverage"/>
<converter file="bed_to_interval_index_converter.xml" target_datatype="interval_index"/>
</datatype>
<datatype extension="binseq.zip" type="galaxy.datatypes.images:Binseq" mimetype="application/zip" display_in_upload="true"/>
<datatype extension="len" type="galaxy.datatypes.chrominfo:ChromInfo" display_in_upload="true">
<!-- no converters yet -->
</datatype>
<datatype extension="coverage" type="galaxy.datatypes.coverage:LastzCoverage" display_in_upload="true">
<indexer file="coverage.xml" />
</datatype>
<datatype extension="customtrack" type="galaxy.datatypes.interval:CustomTrack"/>
<datatype extension="csfasta" type="galaxy.datatypes.sequence:csFasta" display_in_upload="true"/>
<datatype extension="data" type="galaxy.datatypes.data:Data" mimetype="application/octet-stream"/>
<datatype extension="fasta" type="galaxy.datatypes.sequence:Fasta" display_in_upload="true">
<converter file="fasta_to_tabular_converter.xml" target_datatype="tabular"/>
</datatype>
<datatype extension="fastq" type="galaxy.datatypes.sequence:Fastq" display_in_upload="true"/>
<datatype extension="fastqsanger" type="galaxy.datatypes.sequence:FastqSanger" display_in_upload="true"/>
<datatype extension="genetrack" type="galaxy.datatypes.tracks:GeneTrack"/>
<datatype extension="gff" type="galaxy.datatypes.interval:Gff" display_in_upload="true">
<converter file="gff_to_bed_converter.xml" target_datatype="bed"/>
</datatype>
<datatype extension="gff3" type="galaxy.datatypes.interval:Gff3" display_in_upload="true"/>
<datatype extension="gif" type="galaxy.datatypes.images:Image" mimetype="image/gif"/>
<datatype extension="gmaj.zip" type="galaxy.datatypes.images:Gmaj" mimetype="application/zip"/>
<datatype extension="html" type="galaxy.datatypes.images:Html" mimetype="text/html"/>
<datatype extension="interval" type="galaxy.datatypes.interval:Interval" display_in_upload="true">
<converter file="interval_to_bed_converter.xml" target_datatype="bed"/>
<indexer file="interval_awk.xml" />
</datatype>
<datatype extension="jpg" type="galaxy.datatypes.images:Image" mimetype="image/jpeg"/>
<datatype extension="laj" type="galaxy.datatypes.images:Laj"/>
<datatype extension="lav" type="galaxy.datatypes.sequence:Lav" display_in_upload="true"/>
<datatype extension="maf" type="galaxy.datatypes.sequence:Maf" display_in_upload="true">
<converter file="maf_to_fasta_converter.xml" target_datatype="fasta"/>
<converter file="maf_to_interval_converter.xml" target_datatype="interval"/>
</datatype>
<datatype extension="pdf" type="galaxy.datatypes.images:Image" mimetype="application/pdf"/>
<datatype extension="png" type="galaxy.datatypes.images:Image" mimetype="image/png"/>
<datatype extension="qualsolexa" type="galaxy.datatypes.qualityscore:QualityScoreSolexa" display_in_upload="true"/>
<datatype extension="qualsolid" type="galaxy.datatypes.qualityscore:QualityScoreSOLiD" display_in_upload="true"/>
<datatype extension="qual454" type="galaxy.datatypes.qualityscore:QualityScore454" display_in_upload="true"/>
<datatype extension="sam" type="galaxy.datatypes.tabular:Sam" display_in_upload="true"/>
<datatype extension="scf" type="galaxy.datatypes.images:Scf" mimetype="application/octet-stream" display_in_upload="true"/>
<datatype extension="taxonomy" type="galaxy.datatypes.tabular:Taxonomy" display_in_upload="true"/>
<datatype extension="tabular" type="galaxy.datatypes.tabular:Tabular" display_in_upload="true"/>
<datatype extension="txt" type="galaxy.datatypes.data:Text" display_in_upload="true"/>
<datatype extension="blastxml" type="galaxy.datatypes.xml:BlastXml" display_in_upload="true"/>
<datatype extension="txtseq.zip" type="galaxy.datatypes.images:Txtseq" mimetype="application/zip" display_in_upload="true"/>
<datatype extension="wig" type="galaxy.datatypes.interval:Wiggle" display_in_upload="true">
<converter file="wiggle_to_array_tree_converter.xml" target_datatype="array_tree"/>
</datatype>
<datatype extension="array_tree" type="galaxy.datatypes.data:Data" />
<datatype extension="interval_index" type="galaxy.datatypes.data:Data" />
<!-- EMBOSS TOOLS -->
<datatype extension="acedb" type="galaxy.datatypes.data:Text"/>
<datatype extension="asn1" type="galaxy.datatypes.data:Text"/>
<datatype extension="btwisted" type="galaxy.datatypes.data:Text"/>
<datatype extension="cai" type="galaxy.datatypes.data:Text"/>
<datatype extension="charge" type="galaxy.datatypes.data:Text"/>
<datatype extension="checktrans" type="galaxy.datatypes.data:Text"/>
<datatype extension="chips" type="galaxy.datatypes.data:Text"/>
<datatype extension="clustal" type="galaxy.datatypes.data:Text"/>
<datatype extension="codata" type="galaxy.datatypes.data:Text"/>
<datatype extension="codcmp" type="galaxy.datatypes.data:Text"/>
<datatype extension="coderet" type="galaxy.datatypes.data:Text"/>
<datatype extension="compseq" type="galaxy.datatypes.data:Text"/>
<datatype extension="cpgplot" type="galaxy.datatypes.data:Text"/>
<datatype extension="cpgreport" type="galaxy.datatypes.data:Text"/>
<datatype extension="cusp" type="galaxy.datatypes.data:Text"/>
<datatype extension="cut" type="galaxy.datatypes.data:Text"/>
<datatype extension="dan" type="galaxy.datatypes.data:Text"/>
<datatype extension="dbmotif" type="galaxy.datatypes.data:Text"/>
<datatype extension="diffseq" type="galaxy.datatypes.data:Text"/>
<datatype extension="digest" type="galaxy.datatypes.data:Text"/>
<datatype extension="dreg" type="galaxy.datatypes.data:Text"/>
<datatype extension="einverted" type="galaxy.datatypes.data:Text"/>
<datatype extension="embl" type="galaxy.datatypes.data:Text"/>
<datatype extension="epestfind" type="galaxy.datatypes.data:Text"/>
<datatype extension="equicktandem" type="galaxy.datatypes.data:Text"/>
<datatype extension="est2genome" type="galaxy.datatypes.data:Text"/>
<datatype extension="etandem" type="galaxy.datatypes.data:Text"/>
<datatype extension="excel" type="galaxy.datatypes.data:Text"/>
<datatype extension="feattable" type="galaxy.datatypes.data:Text"/>
<datatype extension="fitch" type="galaxy.datatypes.data:Text"/>
<datatype extension="freak" type="galaxy.datatypes.data:Text"/>
<datatype extension="fuzznuc" type="galaxy.datatypes.data:Text"/>
<datatype extension="fuzzpro" type="galaxy.datatypes.data:Text"/>
<datatype extension="fuzztran" type="galaxy.datatypes.data:Text"/>
<datatype extension="garnier" type="galaxy.datatypes.data:Text"/>
<datatype extension="gcg" type="galaxy.datatypes.data:Text"/>
<datatype extension="geecee" type="galaxy.datatypes.data:Text"/>
<datatype extension="genbank" type="galaxy.datatypes.data:Text"/>
<datatype extension="helixturnhelix" type="galaxy.datatypes.data:Text"/>
<datatype extension="hennig86" type="galaxy.datatypes.data:Text"/>
<datatype extension="hmoment" type="galaxy.datatypes.data:Text"/>
<datatype extension="ig" type="galaxy.datatypes.data:Text"/>
<datatype extension="isochore" type="galaxy.datatypes.data:Text"/>
<datatype extension="jackknifer" type="galaxy.datatypes.data:Text"/>
<datatype extension="jackknifernon" type="galaxy.datatypes.data:Text"/>
<datatype extension="markx10" type="galaxy.datatypes.data:Text"/>
<datatype extension="markx1" type="galaxy.datatypes.data:Text"/>
<datatype extension="markx0" type="galaxy.datatypes.data:Text"/>
<datatype extension="markx3" type="galaxy.datatypes.data:Text"/>
<datatype extension="markx2" type="galaxy.datatypes.data:Text"/>
<datatype extension="match" type="galaxy.datatypes.data:Text"/>
<datatype extension="mega" type="galaxy.datatypes.data:Text"/>
<datatype extension="meganon" type="galaxy.datatypes.data:Text"/>
<datatype extension="motif" type="galaxy.datatypes.data:Text"/>
<datatype extension="msf" type="galaxy.datatypes.data:Text"/>
<datatype extension="nametable" type="galaxy.datatypes.data:Text"/>
<datatype extension="ncbi" type="galaxy.datatypes.data:Text"/>
<datatype extension="needle" type="galaxy.datatypes.data:Text"/>
<datatype extension="newcpgreport" type="galaxy.datatypes.data:Text"/>
<datatype extension="newcpgseek" type="galaxy.datatypes.data:Text"/>
<datatype extension="nexus" type="galaxy.datatypes.data:Text"/>
<datatype extension="nexusnon" type="galaxy.datatypes.data:Text"/>
<datatype extension="noreturn" type="galaxy.datatypes.data:Text"/>
<datatype extension="pair" type="galaxy.datatypes.data:Text"/>
<datatype extension="palindrome" type="galaxy.datatypes.data:Text"/>
<datatype extension="pepcoil" type="galaxy.datatypes.data:Text"/>
<datatype extension="pepinfo" type="galaxy.datatypes.data:Text"/>
<datatype extension="pepstats" type="galaxy.datatypes.data:Text"/>
<datatype extension="phylip" type="galaxy.datatypes.data:Text"/>
<datatype extension="phylipnon" type="galaxy.datatypes.data:Text"/>
<datatype extension="pir" type="galaxy.datatypes.data:Text"/>
<datatype extension="polydot" type="galaxy.datatypes.data:Text"/>
<datatype extension="preg" type="galaxy.datatypes.data:Text"/>
<datatype extension="prettyseq" type="galaxy.datatypes.data:Text"/>
<datatype extension="primersearch" type="galaxy.datatypes.data:Text"/>
<datatype extension="regions" type="galaxy.datatypes.data:Text"/>
<datatype extension="score" type="galaxy.datatypes.data:Text"/>
<datatype extension="selex" type="galaxy.datatypes.data:Text"/>
<datatype extension="seqtable" type="galaxy.datatypes.data:Text"/>
<datatype extension="showfeat" type="galaxy.datatypes.data:Text"/>
<datatype extension="showorf" type="galaxy.datatypes.data:Text"/>
<datatype extension="simple" type="galaxy.datatypes.data:Text"/>
<datatype extension="sixpack" type="galaxy.datatypes.data:Text"/>
<datatype extension="srs" type="galaxy.datatypes.data:Text"/>
<datatype extension="srspair" type="galaxy.datatypes.data:Text"/>
<datatype extension="staden" type="galaxy.datatypes.data:Text"/>
<datatype extension="strider" type="galaxy.datatypes.data:Text"/>
<datatype extension="supermatcher" type="galaxy.datatypes.data:Text"/>
<datatype extension="swiss" type="galaxy.datatypes.data:Text"/>
<datatype extension="syco" type="galaxy.datatypes.data:Text"/>
<datatype extension="table" type="galaxy.datatypes.data:Text"/>
<datatype extension="textsearch" type="galaxy.datatypes.data:Text"/>
<datatype extension="vectorstrip" type="galaxy.datatypes.data:Text"/>
<datatype extension="wobble" type="galaxy.datatypes.data:Text"/>
<datatype extension="wordcount" type="galaxy.datatypes.data:Text"/>
<datatype extension="tagseq" type="galaxy.datatypes.data:Text"/>
<!-- Start RGenetics Datatypes -->
<!-- genome graphs ucsc file - first col is always marker then numeric values to plot -->
<datatype extension="gg" type="galaxy.datatypes.genetics:GenomeGraphs"/>
<datatype extension="rgenetics" type="galaxy.datatypes.genetics:Rgenetics"/>
<!-- linkage format pedigree (separate .map file) -->
<datatype extension="lped" type="galaxy.datatypes.genetics:Lped" display_in_upload="true"/>
<!-- plink compressed file - has bed extension unfortunately -->
<datatype extension="pbed" type="galaxy.datatypes.genetics:Pbed" display_in_upload="true"/>
<!-- eigenstrat pedigree input file -->
<datatype extension="eigenstratgeno" type="galaxy.datatypes.genetics:Eigenstratgeno"/>
<!-- eigenstrat pca output file for adjusted eigenQTL eg -->
<datatype extension="eigenstratpca" type="galaxy.datatypes.genetics:Eigenstratpca"/>
<!-- fbat/pbat format pedigree (header row of marker names) -->
<datatype extension="fped" type="galaxy.datatypes.genetics:Fped"/>
<!-- part of linkage format pedigree -->
<datatype extension="lmap" type="galaxy.datatypes.genetics:Lmap"/>
<!-- phenotype file - fbat format -->
<datatype extension="fphe" type="galaxy.datatypes.genetics:Fphe"/>
<!-- phenotype file - plink format -->
<datatype extension="pphe" type="galaxy.datatypes.genetics:Pphe"/>
<datatype extension="snptest" type="galaxy.datatypes.genetics:Snptest"/>
<datatype extension="snpmatrix" type="galaxy.datatypes.genetics:SNPMatrix"/>
<datatype extension="xls" type="galaxy.datatypes.tabular:Tabular"/>
<!-- End RGenetics Datatypes -->
</registration>
<sniffers>
<!--
The order in which Galaxy attempts to determine data types is
important because some formats are much more loosely defined
than others. The following list should be the most rigidly
defined format first, followed by next-most rigidly defined,
and so on.
-->
<sniffer type="galaxy.datatypes.xml:BlastXml"/>
<sniffer type="galaxy.datatypes.sequence:Maf"/>
<sniffer type="galaxy.datatypes.sequence:Lav"/>
<sniffer type="galaxy.datatypes.sequence:csFasta"/>
<sniffer type="galaxy.datatypes.qualityscore:QualityScoreSOLiD"/>
<sniffer type="galaxy.datatypes.qualityscore:QualityScore454"/>
<sniffer type="galaxy.datatypes.sequence:Fasta"/>
<sniffer type="galaxy.datatypes.sequence:Fastq"/>
<sniffer type="galaxy.datatypes.interval:Wiggle"/>
<sniffer type="galaxy.datatypes.images:Html"/>
<sniffer type="galaxy.datatypes.sequence:Axt"/>
<sniffer type="galaxy.datatypes.interval:Bed"/>
<sniffer type="galaxy.datatypes.interval:CustomTrack"/>
<sniffer type="galaxy.datatypes.interval:Gff"/>
<sniffer type="galaxy.datatypes.interval:Gff3"/>
<sniffer type="galaxy.datatypes.interval:Interval"/>
<sniffer type="galaxy.datatypes.tabular:Sam"/>
</sniffers>
<registration converters_path="lib/galaxy/datatypes/converters">
<datatype extension="ab1" type="galaxy.datatypes.binary:Ab1" mimetype="application/octet-stream" display_in_upload="true"/>
<datatype extension="axt" type="galaxy.datatypes.sequence:Axt" display_in_upload="true"/>
<datatype extension="bam" type="galaxy.datatypes.binary:Bam" mimetype="application/octet-stream"/>
<datatype extension="bed" type="galaxy.datatypes.interval:Bed" display_in_upload="true">
<converter file="bed_to_gff_converter.xml" target_datatype="gff"/>
<converter file="interval_to_coverage.xml" target_datatype="coverage"/>
<converter file="bed_to_interval_index_converter.xml" target_datatype="interval_index"/>
</datatype>
<datatype extension="binseq.zip" type="galaxy.datatypes.binary:Binseq" mimetype="application/zip" display_in_upload="true"/>
<datatype extension="len" type="galaxy.datatypes.chrominfo:ChromInfo" display_in_upload="true">
<!-- no converters yet -->
</datatype>
<datatype extension="coverage" type="galaxy.datatypes.coverage:LastzCoverage" display_in_upload="true">
<indexer file="coverage.xml" />
</datatype>
<datatype extension="customtrack" type="galaxy.datatypes.interval:CustomTrack"/>
<datatype extension="csfasta" type="galaxy.datatypes.sequence:csFasta" display_in_upload="true"/>
<datatype extension="data" type="galaxy.datatypes.data:Data" mimetype="application/octet-stream"/>
<datatype extension="fasta" type="galaxy.datatypes.sequence:Fasta" display_in_upload="true">
<converter file="fasta_to_tabular_converter.xml" target_datatype="tabular"/>
</datatype>
<datatype extension="fastq" type="galaxy.datatypes.sequence:Fastq" display_in_upload="true"/>
<datatype extension="fastqsanger" type="galaxy.datatypes.sequence:FastqSanger" display_in_upload="true"/>
<datatype extension="genetrack" type="galaxy.datatypes.tracks:GeneTrack"/>
<datatype extension="gff" type="galaxy.datatypes.interval:Gff" display_in_upload="true">
<converter file="gff_to_bed_converter.xml" target_datatype="bed"/>
</datatype>
<datatype extension="gff3" type="galaxy.datatypes.interval:Gff3" display_in_upload="true"/>
<datatype extension="gif" type="galaxy.datatypes.images:Image" mimetype="image/gif"/>
<datatype extension="gmaj.zip" type="galaxy.datatypes.images:Gmaj" mimetype="application/zip"/>
<datatype extension="html" type="galaxy.datatypes.images:Html" mimetype="text/html"/>
<datatype extension="interval" type="galaxy.datatypes.interval:Interval" display_in_upload="true">
<converter file="interval_to_bed_converter.xml" target_datatype="bed"/>
<indexer file="interval_awk.xml" />
</datatype>
<datatype extension="jpg" type="galaxy.datatypes.images:Image" mimetype="image/jpeg"/>
<datatype extension="laj" type="galaxy.datatypes.images:Laj"/>
<datatype extension="lav" type="galaxy.datatypes.sequence:Lav" display_in_upload="true"/>
<datatype extension="maf" type="galaxy.datatypes.sequence:Maf" display_in_upload="true">
<converter file="maf_to_fasta_converter.xml" target_datatype="fasta"/>
<converter file="maf_to_interval_converter.xml" target_datatype="interval"/>
</datatype>
<datatype extension="pdf" type="galaxy.datatypes.images:Image" mimetype="application/pdf"/>
<datatype extension="png" type="galaxy.datatypes.images:Image" mimetype="image/png"/>
<datatype extension="qualsolexa" type="galaxy.datatypes.qualityscore:QualityScoreSolexa" display_in_upload="true"/>
<datatype extension="qualsolid" type="galaxy.datatypes.qualityscore:QualityScoreSOLiD" display_in_upload="true"/>
<datatype extension="qual454" type="galaxy.datatypes.qualityscore:QualityScore454" display_in_upload="true"/>
<datatype extension="sam" type="galaxy.datatypes.tabular:Sam" display_in_upload="true"/>
<datatype extension="scf" type="galaxy.datatypes.binary:Scf" mimetype="application/octet-stream" display_in_upload="true"/>
<datatype extension="sff" type="galaxy.datatypes.binary:Sff" mimetype="application/octet-stream" display_in_upload="true"/>
<datatype extension="taxonomy" type="galaxy.datatypes.tabular:Taxonomy" display_in_upload="true"/>
<datatype extension="tabular" type="galaxy.datatypes.tabular:Tabular" display_in_upload="true"/>
<datatype extension="txt" type="galaxy.datatypes.data:Text" display_in_upload="true"/>
<datatype extension="blastxml" type="galaxy.datatypes.xml:BlastXml" display_in_upload="true"/>
<datatype extension="txtseq.zip" type="galaxy.datatypes.data:Txtseq" mimetype="application/zip" display_in_upload="true"/>
<datatype extension="wig" type="galaxy.datatypes.interval:Wiggle" display_in_upload="true">
<converter file="wiggle_to_array_tree_converter.xml" target_datatype="array_tree"/>
</datatype>
<datatype extension="array_tree" type="galaxy.datatypes.data:Data" />
<datatype extension="interval_index" type="galaxy.datatypes.data:Data" />
<!-- Start EMBOSS tools -->
<datatype extension="acedb" type="galaxy.datatypes.data:Text"/>
<datatype extension="asn1" type="galaxy.datatypes.data:Text"/>
<datatype extension="btwisted" type="galaxy.datatypes.data:Text"/>
<datatype extension="cai" type="galaxy.datatypes.data:Text"/>
<datatype extension="charge" type="galaxy.datatypes.data:Text"/>
<datatype extension="checktrans" type="galaxy.datatypes.data:Text"/>
<datatype extension="chips" type="galaxy.datatypes.data:Text"/>
<datatype extension="clustal" type="galaxy.datatypes.data:Text"/>
<datatype extension="codata" type="galaxy.datatypes.data:Text"/>
<datatype extension="codcmp" type="galaxy.datatypes.data:Text"/>
<datatype extension="coderet" type="galaxy.datatypes.data:Text"/>
<datatype extension="compseq" type="galaxy.datatypes.data:Text"/>
<datatype extension="cpgplot" type="galaxy.datatypes.data:Text"/>
<datatype extension="cpgreport" type="galaxy.datatypes.data:Text"/>
<datatype extension="cusp" type="galaxy.datatypes.data:Text"/>
<datatype extension="cut" type="galaxy.datatypes.data:Text"/>
<datatype extension="dan" type="galaxy.datatypes.data:Text"/>
<datatype extension="dbmotif" type="galaxy.datatypes.data:Text"/>
<datatype extension="diffseq" type="galaxy.datatypes.data:Text"/>
<datatype extension="digest" type="galaxy.datatypes.data:Text"/>
<datatype extension="dreg" type="galaxy.datatypes.data:Text"/>
<datatype extension="einverted" type="galaxy.datatypes.data:Text"/>
<datatype extension="embl" type="galaxy.datatypes.data:Text"/>
<datatype extension="epestfind" type="galaxy.datatypes.data:Text"/>
<datatype extension="equicktandem" type="galaxy.datatypes.data:Text"/>
<datatype extension="est2genome" type="galaxy.datatypes.data:Text"/>
<datatype extension="etandem" type="galaxy.datatypes.data:Text"/>
<datatype extension="excel" type="galaxy.datatypes.data:Text"/>
<datatype extension="feattable" type="galaxy.datatypes.data:Text"/>
<datatype extension="fitch" type="galaxy.datatypes.data:Text"/>
<datatype extension="freak" type="galaxy.datatypes.data:Text"/>
<datatype extension="fuzznuc" type="galaxy.datatypes.data:Text"/>
<datatype extension="fuzzpro" type="galaxy.datatypes.data:Text"/>
<datatype extension="fuzztran" type="galaxy.datatypes.data:Text"/>
<datatype extension="garnier" type="galaxy.datatypes.data:Text"/>
<datatype extension="gcg" type="galaxy.datatypes.data:Text"/>
<datatype extension="geecee" type="galaxy.datatypes.data:Text"/>
<datatype extension="genbank" type="galaxy.datatypes.data:Text"/>
<datatype extension="helixturnhelix" type="galaxy.datatypes.data:Text"/>
<datatype extension="hennig86" type="galaxy.datatypes.data:Text"/>
<datatype extension="hmoment" type="galaxy.datatypes.data:Text"/>
<datatype extension="ig" type="galaxy.datatypes.data:Text"/>
<datatype extension="isochore" type="galaxy.datatypes.data:Text"/>
<datatype extension="jackknifer" type="galaxy.datatypes.data:Text"/>
<datatype extension="jackknifernon" type="galaxy.datatypes.data:Text"/>
<datatype extension="markx10" type="galaxy.datatypes.data:Text"/>
<datatype extension="markx1" type="galaxy.datatypes.data:Text"/>
<datatype extension="markx0" type="galaxy.datatypes.data:Text"/>
<datatype extension="markx3" type="galaxy.datatypes.data:Text"/>
<datatype extension="markx2" type="galaxy.datatypes.data:Text"/>
<datatype extension="match" type="galaxy.datatypes.data:Text"/>
<datatype extension="mega" type="galaxy.datatypes.data:Text"/>
<datatype extension="meganon" type="galaxy.datatypes.data:Text"/>
<datatype extension="motif" type="galaxy.datatypes.data:Text"/>
<datatype extension="msf" type="galaxy.datatypes.data:Text"/>
<datatype extension="nametable" type="galaxy.datatypes.data:Text"/>
<datatype extension="ncbi" type="galaxy.datatypes.data:Text"/>
<datatype extension="needle" type="galaxy.datatypes.data:Text"/>
<datatype extension="newcpgreport" type="galaxy.datatypes.data:Text"/>
<datatype extension="newcpgseek" type="galaxy.datatypes.data:Text"/>
<datatype extension="nexus" type="galaxy.datatypes.data:Text"/>
<datatype extension="nexusnon" type="galaxy.datatypes.data:Text"/>
<datatype extension="noreturn" type="galaxy.datatypes.data:Text"/>
<datatype extension="pair" type="galaxy.datatypes.data:Text"/>
<datatype extension="palindrome" type="galaxy.datatypes.data:Text"/>
<datatype extension="pepcoil" type="galaxy.datatypes.data:Text"/>
<datatype extension="pepinfo" type="galaxy.datatypes.data:Text"/>
<datatype extension="pepstats" type="galaxy.datatypes.data:Text"/>
<datatype extension="phylip" type="galaxy.datatypes.data:Text"/>
<datatype extension="phylipnon" type="galaxy.datatypes.data:Text"/>
<datatype extension="pir" type="galaxy.datatypes.data:Text"/>
<datatype extension="polydot" type="galaxy.datatypes.data:Text"/>
<datatype extension="preg" type="galaxy.datatypes.data:Text"/>
<datatype extension="prettyseq" type="galaxy.datatypes.data:Text"/>
<datatype extension="primersearch" type="galaxy.datatypes.data:Text"/>
<datatype extension="regions" type="galaxy.datatypes.data:Text"/>
<datatype extension="score" type="galaxy.datatypes.data:Text"/>
<datatype extension="selex" type="galaxy.datatypes.data:Text"/>
<datatype extension="seqtable" type="galaxy.datatypes.data:Text"/>
<datatype extension="showfeat" type="galaxy.datatypes.data:Text"/>
<datatype extension="showorf" type="galaxy.datatypes.data:Text"/>
<datatype extension="simple" type="galaxy.datatypes.data:Text"/>
<datatype extension="sixpack" type="galaxy.datatypes.data:Text"/>
<datatype extension="srs" type="galaxy.datatypes.data:Text"/>
<datatype extension="srspair" type="galaxy.datatypes.data:Text"/>
<datatype extension="staden" type="galaxy.datatypes.data:Text"/>
<datatype extension="strider" type="galaxy.datatypes.data:Text"/>
<datatype extension="supermatcher" type="galaxy.datatypes.data:Text"/>
<datatype extension="swiss" type="galaxy.datatypes.data:Text"/>
<datatype extension="syco" type="galaxy.datatypes.data:Text"/>
<datatype extension="table" type="galaxy.datatypes.data:Text"/>
<datatype extension="textsearch" type="galaxy.datatypes.data:Text"/>
<datatype extension="vectorstrip" type="galaxy.datatypes.data:Text"/>
<datatype extension="wobble" type="galaxy.datatypes.data:Text"/>
<datatype extension="wordcount" type="galaxy.datatypes.data:Text"/>
<datatype extension="tagseq" type="galaxy.datatypes.data:Text"/>
<!-- End EMBOSS tools -->
<!-- Start RGenetics Datatypes -->
<datatype extension="affybatch" type="galaxy.datatypes.genetics:Affybatch" display_in_upload="true"/>
<!-- eigenstrat pedigree input file -->
<datatype extension="eigenstratgeno" type="galaxy.datatypes.genetics:Eigenstratgeno"/>
<!-- eigenstrat pca output file for adjusted eigenQTL eg -->
<datatype extension="eigenstratpca" type="galaxy.datatypes.genetics:Eigenstratpca"/>
<datatype extension="eset" type="galaxy.datatypes.genetics:Eset" display_in_upload="true" />
<!-- fbat/pbat format pedigree (header row of marker names) -->
<datatype extension="fped" type="galaxy.datatypes.genetics:Fped" display_in_upload="true"/>
<!-- phenotype file - fbat format -->
<datatype extension="fphe" type="galaxy.datatypes.genetics:Fphe" display_in_upload="true" mimetype="text/html"/>
<!-- genome graphs ucsc file - first col is always marker then numeric values to plot -->
<datatype extension="gg" type="galaxy.datatypes.genetics:GenomeGraphs"/>
<!-- part of linkage format pedigree -->
<datatype extension="lmap" type="galaxy.datatypes.genetics:Lmap" display_in_upload="true"/>
<datatype extension="malist" type="galaxy.datatypes.genetics:MAlist" display_in_upload="true"/>
<!-- linkage format pedigree (separate .map file) -->
<datatype extension="lped" type="galaxy.datatypes.genetics:Lped" display_in_upload="true">
<converter file="lped_to_fped_converter.xml" target_datatype="fped"/>
<converter file="lped_to_pbed_converter.xml" target_datatype="pbed"/>
</datatype>
<!-- plink compressed file - has bed extension unfortunately -->
<datatype extension="pbed" type="galaxy.datatypes.genetics:Pbed" display_in_upload="true">
<converter file="pbed_to_lped_converter.xml" target_datatype="lped"/>
</datatype>
<datatype extension="pheno" type="galaxy.datatypes.genetics:Pheno"/>
<!-- phenotype file - plink format -->
<datatype extension="pphe" type="galaxy.datatypes.genetics:Pphe" display_in_upload="true" mimetype="text/html"/>
<datatype extension="rexpbase" type="galaxy.datatypes.genetics:RexpBase"/>
<datatype extension="rgenetics" type="galaxy.datatypes.genetics:Rgenetics"/>
<datatype extension="snptest" type="galaxy.datatypes.genetics:Snptest" display_in_upload="true"/>
<datatype extension="snpmatrix" type="galaxy.datatypes.genetics:SNPMatrix" display_in_upload="true"/>
<datatype extension="xls" type="galaxy.datatypes.tabular:Tabular"/>
<!-- End RGenetics Datatypes -->
</registration>
<sniffers>
<!--
The order in which Galaxy attempts to determine data types is
important because some formats are much more loosely defined
than others. The following list should be the most rigidly
defined format first, followed by next-most rigidly defined,
and so on.
-->
<sniffer type="galaxy.datatypes.binary:Sff"/>
<sniffer type="galaxy.datatypes.xml:BlastXml"/>
<sniffer type="galaxy.datatypes.sequence:Maf"/>
<sniffer type="galaxy.datatypes.sequence:Lav"/>
<sniffer type="galaxy.datatypes.sequence:csFasta"/>
<sniffer type="galaxy.datatypes.qualityscore:QualityScoreSOLiD"/>
<sniffer type="galaxy.datatypes.qualityscore:QualityScore454"/>
<sniffer type="galaxy.datatypes.sequence:Fasta"/>
<sniffer type="galaxy.datatypes.sequence:Fastq"/>
<sniffer type="galaxy.datatypes.interval:Wiggle"/>
<sniffer type="galaxy.datatypes.images:Html"/>
<sniffer type="galaxy.datatypes.sequence:Axt"/>
<sniffer type="galaxy.datatypes.interval:Bed"/>
<sniffer type="galaxy.datatypes.interval:CustomTrack"/>
<sniffer type="galaxy.datatypes.interval:Gff"/>
<sniffer type="galaxy.datatypes.interval:Gff3"/>
<sniffer type="galaxy.datatypes.interval:Interval"/>
<sniffer type="galaxy.datatypes.tabular:Sam"/>
</sniffers>
</datatypes>
dist-eggs.ini
+6 -3
View File
@@ -23,6 +23,9 @@ py2.4-macosx-10.3-fat-ucs2 = medeski.bx.psu.edu /usr/local/bin/python2.4
py2.5-macosx-10.3-fat-ucs2 = medeski.bx.psu.edu /usr/local/bin/python2.5
py2.6-macosx-10.3-fat-ucs2 = medeski.bx.psu.edu /usr/local/bin/python2.6
py2.5-macosx-10.5-i386-ucs2 = lion.bx.psu.edu /usr/bin/python2.5
py2.4-solaris-2.10-i86pc-ucs2 = thumper.bx.psu.edu /depot/projects/pythons/solaris-2.10-i86pc-ucs2/bin/python2.4
py2.5-solaris-2.10-i86pc-ucs2 = thumper.bx.psu.edu /depot/projects/pythons/solaris-2.10-i86pc-ucs2/bin/python2.5
py2.6-solaris-2.10-i86pc-ucs2 = thumper.bx.psu.edu /depot/projects/pythons/solaris-2.10-i86pc-ucs2/bin/python2.6
py2.4-solaris-2.11-i86pc-ucs2 = victory.bx.psu.edu /depot/projects/pythons/solaris-2.11-i86pc-ucs2/bin/python2.4
py2.5-solaris-2.11-i86pc-ucs2 = victory.bx.psu.edu /depot/projects/pythons/solaris-2.11-i86pc-ucs2/bin/python2.5
py2.6-solaris-2.11-i86pc-ucs2 = victory.bx.psu.edu /depot/projects/pythons/solaris-2.11-i86pc-ucs2/bin/python2.6
@@ -47,9 +50,9 @@ py2.4-macosx = py2.4-macosx-10.3-fat-ucs2
py2.5-macosx = py2.5-macosx-10.3-fat-ucs2 py2.5-macosx-10.5-i386-ucs2
py2.6-macosx = py2.6-macosx-10.3-fat-ucs2
macosx = py2.4-macosx py2.5-macosx py2.6-macosx
py2.4-solaris = py2.4-solaris-2.11-i86pc-ucs2 py2.4-solaris-2.10-sun4u-ucs2
py2.5-solaris = py2.5-solaris-2.11-i86pc-ucs2 py2.5-solaris-2.10-sun4u-ucs2
py2.6-solaris = py2.6-solaris-2.11-i86pc-ucs2 py2.6-solaris-2.10-sun4u-ucs2
py2.4-solaris = py2.4-solaris-2.10-i86pc-ucs2 py2.4-solaris-2.11-i86pc-ucs2 py2.4-solaris-2.10-sun4u-ucs2
py2.5-solaris = py2.5-solaris-2.10-i86pc-ucs2 py2.5-solaris-2.11-i86pc-ucs2 py2.5-solaris-2.10-sun4u-ucs2
py2.6-solaris = py2.6-solaris-2.10-i86pc-ucs2 py2.6-solaris-2.11-i86pc-ucs2 py2.6-solaris-2.10-sun4u-ucs2
solaris = py2.4-solaris py2.5-solaris py2.6-solaris
py2.4-all = py2.4-linux py2.4-macosx py2.4-solaris
py2.5-all = py2.5-linux py2.5-macosx py2.5-solaris
eggs.ini
+7 -6
View File
@@ -19,7 +19,7 @@ MySQL_python = 1.2.2
pbs_python = 2.9.4
psycopg2 = 2.0.6
pycrypto = 2.0.1
pysqlite = 2.3.5
pysqlite = 2.5.6
python_lzo = 1.08
threadframe = 0.2
guppy = 0.1.8
@@ -57,11 +57,12 @@ boto = 1.8d
; extra version information
[tags]
psycopg2 = _8.2.6_static
pysqlite = _3.5.4_static
pysqlite = _static
MySQL_python = _5.0.67_static
python_lzo = _static
bx_python = _dev_r4bf1f32e6b76
GeneTrack = _dev_raa786e9fc131d998e532a1aef39d108850c9e93d
GeneTrack = _dev_e380f21c704218622155b9d230a44b3c9c452524
SQLAlchemy = _dev_r6498
; nose = .dev_r7156749efc58
; source location, necessary for scrambling
@@ -73,7 +74,7 @@ MySQL_python = http://superb-west.dl.sourceforge.net/sourceforge/mysql-python/My
pbs_python = http://ftp.sara.nl/pub/outgoing/pbs_python-2.9.4.tar.gz
psycopg2 = http://initd.org/pub/software/psycopg/PSYCOPG-2-0/psycopg2-2.0.6.tar.gz ftp://ftp-archives.postgresql.org/pub/source/v8.2.6/postgresql-8.2.6.tar.bz2
pycrypto = http://www.amk.ca/files/python/crypto/pycrypto-2.0.1.tar.gz
pysqlite = http://initd.org/pub/software/pysqlite/releases/2.3/2.3.5/pysqlite-2.3.5.tar.gz http://www.sqlite.org/sqlite-source-3_5_4.zip
pysqlite = http://pypi.python.org/packages/source/p/pysqlite/pysqlite-2.5.6.tar.gz
python_lzo = http://www.oberhumer.com/opensource/lzo/download/LZO-v1/python-lzo-1.08.tar.gz http://www.oberhumer.com/opensource/lzo/download/LZO-v1/lzo-1.08.tar.gz
threadframe = http://www.majid.info/python/threadframe/threadframe-0.2.tar.gz
guppy = http://pypi.python.org/packages/source/g/guppy/guppy-0.1.8.tar.gz
@@ -82,7 +83,7 @@ Beaker = http://cheeseshop.python.org/packages/source/B/Beaker/Beaker-1.4.tar.gz
decorator = http://pypi.python.org/packages/source/d/decorator/decorator-3.1.2.tar.gz
docutils = http://downloads.sourceforge.net/docutils/docutils-0.4.tar.gz
elementtree = http://effbot.org/downloads/elementtree-1.2.6-20050316.tar.gz
GeneTrack = http://github.com/ialbert/genetrack-central/tarball/aa786e9fc131d998e532a1aef39d108850c9e93d
GeneTrack = http://github.com/ialbert/genetrack-central/tarball/e380f21c704218622155b9d230a44b3c9c452524
lrucache = http://evan.prodromou.name/lrucache/lrucache-0.2.tar.gz
Mako = http://www.makotemplates.org/downloads/Mako-0.2.5.tar.gz
nose = http://pypi.python.org/packages/source/n/nose/nose-0.11.1.tar.gz
@@ -93,7 +94,7 @@ PasteScript = http://cheeseshop.python.org/packages/source/P/PasteScript/PasteSc
PSI = http://pypi.python.org/packages/source/P/PSI/PSI-0.3b1.1.tar.gz
Routes = http://pypi.python.org/packages/source/R/Routes/Routes-1.11.tar.gz
simplejson = http://cheeseshop.python.org/packages/source/s/simplejson/simplejson-1.5.tar.gz
SQLAlchemy = http://pypi.python.org/packages/source/S/SQLAlchemy/SQLAlchemy-0.5.6.tar.gz
SQLAlchemy = http://dist.g2.bx.psu.edu/SQLAlchemy-0.5.6_r6498.tar.bz2
sqlalchemy_migrate = http://pypi.python.org/packages/source/s/sqlalchemy-migrate/sqlalchemy-migrate-0.5.4.tar.gz
Tempita = http://pypi.python.org/packages/source/T/Tempita/Tempita-0.1.tar.gz
twill = http://darcs.idyll.org/~t/projects/twill-0.9.tar.gz
lib/galaxy/datatypes/binary.py
+156
View File
@@ -0,0 +1,156 @@
"""
Binary classes
"""
import data, logging, binascii
from galaxy.datatypes.metadata import MetadataElement
from galaxy.datatypes import metadata
from galaxy.datatypes.sniff import *
from urllib import urlencode, quote_plus
import zipfile
import os, subprocess, tempfile
log = logging.getLogger(__name__)
sniffable_binary_formats = [ 'sff' ]
# Currently these supported binary data types must be manually set on upload
unsniffable_binary_formats = [ 'ab1', 'scf' ]
class Binary( data.Data ):
"""Binary data"""
def set_peek( self, dataset ):
"""Set the peek and blurb text"""
if not dataset.dataset.purged:
dataset.peek = 'binary data'
dataset.blurb = 'data'
else:
dataset.peek = 'file does not exist'
dataset.blurb = 'file purged from disk'
class Ab1( Binary ):
"""Class describing an ab1 binary sequence file"""
file_ext = "ab1"
def set_peek( self, dataset ):
if not dataset.dataset.purged:
export_url = "/history_add_to?" + urlencode( {'history_id':dataset.history_id,'ext':'ab1','name':'ab1 sequence','info':'Sequence file','dbkey':dataset.dbkey} )
dataset.peek = "Binary ab1 sequence file"
dataset.blurb = data.nice_size( dataset.get_size() )
else:
dataset.peek = 'file does not exist'
dataset.blurb = 'file purged from disk'
def display_peek( self, dataset ):
try:
return dataset.peek
except:
return "Binary ab1 sequence file (%s)" % ( data.nice_size( dataset.get_size() ) )
class Bam( Binary ):
"""Class describing a BAM binary file"""
file_ext = "bam"
MetadataElement( name="bam_index", desc="BAM Index File", param=metadata.FileParameter, readonly=True, no_value=None, visible=False, optional=True )
def init_meta( self, dataset, copy_from=None ):
Binary.init_meta( self, dataset, copy_from=copy_from )
def set_meta( self, dataset, overwrite = True, **kwd ):
"""
Sets index for BAM file.
"""
index_file = dataset.metadata.bam_index
if not index_file:
index_file = dataset.metadata.spec['bam_index'].param.new_file( dataset = dataset )
tmp_dir = tempfile.gettempdir()
tmpf1 = tempfile.NamedTemporaryFile( dir=tmp_dir )
tmpf1bai = '%s.bai' % tmpf1.name
try:
os.system( 'cd %s' % tmp_dir )
os.system( 'cp %s %s' % ( dataset.file_name, tmpf1.name ) )
os.system( 'samtools index %s' % tmpf1.name )
os.system( 'cp %s %s' % ( tmpf1bai, index_file.file_name ) )
except Exception, ex:
sys.stderr.write( 'There was a problem creating the index for the BAM file\n%s\n' + str( ex ) )
tmpf1.close()
if os.path.exists( tmpf1bai ):
os.remove( tmpf1bai )
dataset.metadata.bam_index = index_file
def set_peek( self, dataset ):
if not dataset.dataset.purged:
export_url = "/history_add_to?" + urlencode( {'history_id':dataset.history_id,'ext':'bam','name':'bam alignments','info':'Alignments file','dbkey':dataset.dbkey} )
dataset.peek = "Binary bam alignments file"
dataset.blurb = data.nice_size( dataset.get_size() )
else:
dataset.peek = 'file does not exist'
dataset.blurb = 'file purged from disk'
def display_peek( self, dataset ):
try:
return dataset.peek
except:
return "Binary bam alignments file (%s)" % ( data.nice_size( dataset.get_size() ) )
def get_mime( self ):
"""Returns the mime type of the datatype"""
return 'application/octet-stream'
class Binseq( Binary ):
"""Class describing a zip archive of binary sequence files"""
file_ext = "binseq.zip"
def set_peek( self, dataset ):
if not dataset.dataset.purged:
zip_file = zipfile.ZipFile( dataset.file_name, "r" )
num_files = len( zip_file.namelist() )
dataset.peek = "Archive of %s binary sequence files" % ( str( num_files ) )
dataset.blurb = data.nice_size( dataset.get_size() )
else:
dataset.peek = 'file does not exist'
dataset.blurb = 'file purged from disk'
def display_peek( self, dataset ):
try:
return dataset.peek
except:
return "Binary sequence file archive (%s)" % ( data.nice_size( dataset.get_size() ) )
def get_mime( self ):
"""Returns the mime type of the datatype"""
return 'application/zip'
class Scf( Binary ):
"""Class describing an scf binary sequence file"""
file_ext = "scf"
def set_peek( self, dataset ):
if not dataset.dataset.purged:
export_url = "/history_add_to?" + urlencode({'history_id':dataset.history_id,'ext':'scf','name':'scf sequence','info':'Sequence file','dbkey':dataset.dbkey})
dataset.peek = "Binary scf sequence file"
dataset.blurb = data.nice_size( dataset.get_size() )
else:
dataset.peek = 'file does not exist'
dataset.blurb = 'file purged from disk'
def display_peek( self, dataset ):
try:
return dataset.peek
except:
return "Binary scf sequence file (%s)" % ( data.nice_size( dataset.get_size() ) )
class Sff( Binary ):
""" Standard Flowgram Format (SFF) """
file_ext = "sff"
def __init__( self, **kwd ):
Binary.__init__( self, **kwd )
def sniff( self, filename ):
# The first 4 bytes of any sff file is '.sff', and the file is binary. For details
# about the format, see http://www.ncbi.nlm.nih.gov/Traces/trace.cgi?cmd=show&f=formats&m=doc&s=format
try:
header = open( filename ).read(4)
if binascii.b2a_hex( header ) == binascii.hexlify( '.sff' ):
return True
return False
except Exception, e:
return False
def set_peek( self, dataset ):
if not dataset.dataset.purged:
export_url = "/history_add_to?" + urlencode( {'history_id':dataset.history_id,'ext':'sff','name':'sff file','info':'sff file','dbkey':dataset.dbkey} )
dataset.peek = "Binary sff file"
dataset.blurb = data.nice_size( dataset.get_size() )
else:
dataset.peek = 'file does not exist'
dataset.blurb = 'file purged from disk'
def display_peek( self, dataset ):
try:
return dataset.peek
except:
return "Binary sff file (%s)" % ( data.nice_size( dataset.get_size() ) )
lib/galaxy/datatypes/data.py
+35 -58
View File
@@ -1,4 +1,4 @@
import logging, os, sys, time, tempfile, binascii
import logging, os, sys, time, tempfile
from galaxy import util
from galaxy.util.odict import odict
from galaxy.util.bunch import Bunch
@@ -40,20 +40,18 @@ class Data( object ):
"""
__metaclass__ = DataMeta
"""Add metadata elements"""
# Add metadata elements
MetadataElement( name="dbkey", desc="Database/Build", default="?", param=metadata.DBKeyParameter, multiple=False, no_value="?" )
"""Stores the set of display applications, and viewing methods, supported by this datatype """
# Stores the set of display applications, and viewing methods, supported by this datatype
supported_display_apps = {}
"""If False, the peek is regenerated whenever a dataset of this type is copied"""
# If False, the peek is regenerated whenever a dataset of this type is copied
copy_safe_peek = True
is_binary = True #The dataset contains binary data --> do not space_to_tab or convert newlines, etc. Allow binary file uploads of this type when True.
allow_datatype_change = True #Allow user to change between this datatype and others. If False, this datatype cannot be changed from or into.
# The dataset contains binary data --> do not space_to_tab or convert newlines, etc.
# Allow binary file uploads of this type when True.
is_binary = True
# Allow user to change between this datatype and others. If False, this datatype
# cannot be changed from or into.
allow_datatype_change = True
#Composite datatypes
composite_type = None
composite_files = odict()
@@ -162,6 +160,11 @@ class Data( object ):
info = info.replace( '\r', '<br/>' )
if info.find( '\n' ) >= 0:
info = info.replace( '\n', '<br/>' )
# Convert to unicode to display non-ascii characters.
if type( info ) is not unicode:
info = unicode( info, 'utf-8')
return info
except:
return "info unavailable"
@@ -270,8 +273,6 @@ class Data( object ):
def add_composite_file( self, name, **kwds ):
#self.composite_files = self.composite_files.copy()
self.composite_files[ name ] = self.__new_composite_file( name, **kwds )
def __substitute_composite_key( self, key, composite_file, dataset = None ):
if composite_file.substitute_name_with_metadata:
if dataset:
@@ -303,7 +304,6 @@ class Data( object ):
return files
def generate_auto_primary_file( self, dataset = None ):
raise Exception( "generate_auto_primary_file is not implemented for this datatype." )
@property
def has_resolution(self):
return False
@@ -364,23 +364,37 @@ class Text( Data ):
dataset.peek = 'file does not exist'
dataset.blurb = 'file purged from disk'
class Binary( Data ):
"""Binary data"""
class Txtseq( Data ):
"""Class describing a zip archive of text sequence files"""
file_ext = "txtseq.zip"
def set_peek( self, dataset ):
"""Set the peek and blurb text"""
if not dataset.dataset.purged:
dataset.peek = 'binary data'
dataset.blurb = 'data'
zip_file = zipfile.ZipFile( dataset.file_name, "r" )
num_files = len( zip_file.namelist() )
dataset.peek = "Archive of %s text sequence files" % ( str( num_files ) )
dataset.blurb = data.nice_size( dataset.get_size() )
else:
dataset.peek = 'file does not exist'
dataset.blurb = 'file purged from disk'
def display_peek(self, dataset):
try:
return dataset.peek
except:
return "Text sequence file archive (%s)" % ( data.nice_size( dataset.get_size() ) )
def get_mime(self):
"""Returns the mime type of the datatype"""
return 'application/zip'
class Newick( Text ):
pass
# ------------- Utility methods --------------
def get_test_fname( fname ):
"""Returns test data filename"""
path, name = os.path.split(__file__)
full_path = os.path.join( path, 'test', fname )
return full_path
def nice_size(size):
"""
Returns a readably formatted string with the size
@@ -406,7 +420,6 @@ def nice_size(size):
out = "%.1f %s" % (size, word)
return out
return '??? bytes'
def get_file_peek( file_name, is_multi_byte=False, WIDTH=256, LINE_COUNT=5 ):
"""
Returns the first LINE_COUNT lines wrapped to WIDTH
@@ -443,7 +456,6 @@ def get_file_peek( file_name, is_multi_byte=False, WIDTH=256, LINE_COUNT=5 ):
else:
text = unicode( '\n'.join( lines ), 'utf-8' )
return text
def get_line_count(file_name):
"""Returns the number of lines in a file that are neither null nor comments"""
count = 0
@@ -452,38 +464,3 @@ def get_line_count(file_name):
if line and line[0] != '#':
count += 1
return count
class Newick( Text ):
pass
class Sff( Binary ):
""" Standard Flowgram Format (SFF) """
file_ext = "sff"
def __init__( self, **kwd ):
Binary.__init__(self, **kwd)
def init_meta( self, dataset, copy_from=None ):
Binary.init_meta( self, dataset, copy_from=copy_from )
def sniff( self, filename ):
'''
The first 4 bytes of any sff file is '.sff'
>>> fname = get_test_fname( '1.sff' )
>>> Sff().sniff( fname )
True
'''
header = open( filename ).read(4)
if binascii.b2a_hex( header ) == binascii.hexlify( '.sff' ):
return True
return False
def set_peek( self, dataset ):
if not dataset.dataset.purged:
dataset.peek = "Binary sff file"
dataset.blurb = nice_size( dataset.get_size() )
else:
dataset.peek = 'file does not exist'
dataset.blurb = 'file purged from disk'
def display_peek(self, dataset):
try:
return dataset.peek
except:
return "sff file (%s)" % ( nice_size( dataset.get_size() ) )
lib/galaxy/datatypes/genetics.py
+70 -110
View File
@@ -1,6 +1,5 @@
"""
rgenetics datatypes
Use at your peril
Ross Lazarus
for the rgenetics and galaxy projects
@@ -11,7 +10,6 @@ subsequent row values are all numeric ! Will fail if any non numeric (eg '+' or
ross lazarus for rgenetics
august 20 2007
"""
import logging, os, sys, time, tempfile, shutil, string, glob
import data
from galaxy import util
@@ -26,8 +24,7 @@ from galaxy.datatypes.images import Html
from galaxy.datatypes.interval import Interval
from galaxy.util.hash_util import *
gal_Log = logging.getLogger(__name__)
verbose = False
log = logging.getLogger(__name__)
class GenomeGraphs(Interval):
@@ -48,10 +45,8 @@ class GenomeGraphs(Interval):
"""Initialize datatype, by adding GBrowse display app"""
Interval.__init__(self, **kwd)
self.add_display_app ( 'ucsc', 'display at UCSC', 'as_ucsc_display_file', 'ucsc_links' )
def as_ucsc_display_file( self, dataset, **kwd ):
return open( dataset.file_name )
def set_meta( self, dataset, overwrite = True, **kwd ):
i = 0
for i, line in enumerate( file ( dataset.file_name ) ):
@@ -66,7 +61,6 @@ class GenomeGraphs(Interval):
except:
pass
Interval.set_meta( self, dataset, overwrite = overwrite, skip = i )
def make_html_table( self, dataset, skipchars=[] ):
"""Create HTML table, used for displaying peek"""
out = ['<table cellspacing="0" cellpadding="3">']
@@ -82,7 +76,6 @@ class GenomeGraphs(Interval):
except Exception, exc:
out = "Can't create peek %s" % exc
return out
def get_estimated_display_viewport( self, dataset ):
"""
Return a chrom, start, stop tuple for viewing a file. There are slight differences between gff 2 and gff 3
@@ -118,7 +111,6 @@ class GenomeGraphs(Interval):
return ( seqid, str( start ), str( stop ) )
else:
return ( '', '', '' )
def gbrowse_links( self, dataset, type, app, base_url ):
ret_val = []
if dataset.has_data:
@@ -132,7 +124,6 @@ class GenomeGraphs(Interval):
link = "%s?start=%s&stop=%s&ref=%s&dbkey=%s" % ( site_url, start, stop, seqid, dataset.dbkey )
ret_val.append( ( site_name, link ) )
return ret_val
def ucsc_links( self, dataset, type, app, base_url ):
ret_val = []
if dataset.has_data:
@@ -160,10 +151,8 @@ class GenomeGraphs(Interval):
link = '%s?redirect_url=%s&display_url=%s' % ( internal_url, redirect_url, display_url )
ret_val.append( (site_name, link) )
else:
gal_Log.debug('@@@ gg ucsc_links - no viewport_tuple')
log.debug('@@@ gg ucsc_links - no viewport_tuple')
return ret_val
def sniff( self, filename ):
"""
Determines whether the file is in gff format
@@ -202,20 +191,17 @@ class GenomeGraphs(Interval):
except:
return False
class rgTabList(Tabular):
""" for sampleid and for featureid lists of exclusions or inclusions in the clean tool
"""
for sampleid and for featureid lists of exclusions or inclusions in the clean tool
featureid subsets on statistical criteria -> specialized display such as gg
"""
file_ext = "rgTList"
def __init__(self, **kwd):
"""Initialize featurelistt datatype"""
Tabular.__init__( self, **kwd )
self.column_names = []
def make_html_table( self, dataset, skipchars=[] ):
"""Create HTML table, used for displaying peek"""
out = ['<table cellspacing="0" cellpadding="3">']
@@ -236,23 +222,24 @@ class rgTabList(Tabular):
out = "Can't create peek %s" % exc
return out
class rgSampleList(rgTabList):
""" for sampleid exclusions or inclusions in the clean tool
output from QC eg excess het, gender error, ibd pair member,eigen outlier,excess mendel errors,...
since they can be uploaded, should be flexible
but they are persistent at least
same infrastructure for expression?
"""
for sampleid exclusions or inclusions in the clean tool
output from QC eg excess het, gender error, ibd pair member,eigen outlier,excess mendel errors,...
since they can be uploaded, should be flexible
but they are persistent at least
same infrastructure for expression?
"""
file_ext = "rgSList"
def __init__(self, **kwd):
"""Initialize samplelist datatype"""
"""
Initialize samplelist datatype
"""
rgTabList.__init__( self, **kwd )
self.column_names[0] = 'FID'
self.column_names[1] = 'IID'
# this is what Plink wants as at 2009
def sniff(self,filename):
"""
"""
@@ -264,10 +251,11 @@ class rgSampleList(rgTabList):
return False
class rgFeatureList( rgTabList ):
""" for featureid lists of exclusions or inclusions in the clean tool
output from QC eg low maf, high missingness, bad hwe in controls, excess mendel errors,...
featureid subsets on statistical criteria -> specialized display such as gg
same infrastructure for expression?
"""
for featureid lists of exclusions or inclusions in the clean tool
output from QC eg low maf, high missingness, bad hwe in controls, excess mendel errors,...
featureid subsets on statistical criteria -> specialized display such as gg
same infrastructure for expression?
"""
file_ext = "rgFList"
@@ -276,26 +264,23 @@ class rgFeatureList( rgTabList ):
rgTabList.__init__( self, **kwd )
for i,s in enumerate(['#FeatureId', 'Chr', 'Genpos', 'Mappos']):
self.column_names[i] = s
class Rgenetics(Html):
"""class to use for rgenetics"""
MetadataElement( name="base_name", desc="base name for all transformed versions of this genetic dataset", default="rgenetics",
readonly=True, set_in_upload=True)
"""
class to use for rgenetics
"""
MetadataElement( name="base_name", desc="base name for all transformed versions of this genetic dataset", default="rgenetics", readonly=True, set_in_upload=True)
composite_type = 'auto_primary_file'
allow_datatype_change = False
file_ext = 'rgenetics'
def missing_meta( self, dataset=None, **kwargs):
"""Checks for empty meta values"""
for key, value in dataset.metadata.items():
if not value:
return True
return False
def generate_primary_file( self, dataset = None ):
rval = ['<html><head><title>Rgenetics Galaxy Composite Dataset </title></head><p/>']
rval.append('<div>This composite dataset is composed of the following files:<p/><ul>')
@@ -306,9 +291,9 @@ class Rgenetics(Html):
rval.append( '<li><a href="%s" type="application/binary">%s</a>%s' % ( composite_name, composite_name, opt_text ) )
rval.append( '</ul></div></html>' )
return "\n".join( rval )
def regenerate_primary_file(self,dataset):
"""cannot do this until we are setting metadata
"""
cannot do this until we are setting metadata
"""
def fix(oldpath,newbase):
old,e = os.path.splitext(oldpath)
@@ -332,30 +317,25 @@ class Rgenetics(Html):
f.write("\n".join( rval ))
f.write('\n')
f.close()
def set_meta( self, dataset, **kwd ):
"""for lped/pbed eg
"""
for lped/pbed eg
"""
if kwd.get('overwrite') == False:
if verbose:
gal_Log.debug('@@@ rgenetics set_meta called with overwrite = False')
#log.debug('@@@ rgenetics set_meta called with overwrite = False')
return True
try:
efp = dataset.extra_files_path
except:
if verbose:
gal_Log.debug('@@@rgenetics set_meta failed %s - dataset %s has no efp ?' % (sys.exc_info()[0], dataset.name))
#log.debug('@@@rgenetics set_meta failed %s - dataset %s has no efp ?' % (sys.exc_info()[0], dataset.name))
return False
try:
flist = os.listdir(efp)
except:
if verbose: gal_Log.debug('@@@rgenetics set_meta failed %s - dataset %s has no efp ?' % (sys.exc_info()[0],dataset.name))
flist = os.listdir(efp)
except:
#log.debug('@@@rgenetics set_meta failed %s - dataset %s has no efp ?' % (sys.exc_info()[0],dataset.name))
return False
if len(flist) == 0:
if verbose:
gal_Log.debug('@@@rgenetics set_meta failed - %s efp %s is empty?' % (dataset.name,efp))
#log.debug('@@@rgenetics set_meta failed - %s efp %s is empty?' % (dataset.name,efp))
return False
bn = None
for f in flist:
@@ -372,9 +352,9 @@ class Rgenetics(Html):
dataset.blurb = 'Composite file - Rgenetics Galaxy toolkit'
return True
class SNPMatrix(Rgenetics):
"""fake class to distinguish different species of Rgenetics data collections
"""
fake class to distinguish different species of Rgenetics data collections
"""
file_ext="snpmatrix"
@@ -385,9 +365,9 @@ class SNPMatrix(Rgenetics):
else:
dataset.peek = 'file does not exist'
dataset.blurb = 'file purged from disk'
def sniff(self,filename):
""" need to check the file header hex code
"""
need to check the file header hex code
"""
infile = open(dataset.file_name, "b")
head = infile.read(16)
@@ -397,9 +377,9 @@ class SNPMatrix(Rgenetics):
else:
return True
class Lped(Rgenetics):
"""fake class to distinguish different species of Rgenetics data collections
"""
fake class to distinguish different species of Rgenetics data collections
"""
file_ext="lped"
@@ -408,9 +388,9 @@ class Lped(Rgenetics):
self.add_composite_file( '%s.ped', description = 'Pedigree File', substitute_name_with_metadata = 'base_name', is_binary = True )
self.add_composite_file( '%s.map', description = 'Map File', substitute_name_with_metadata = 'base_name', is_binary = True )
class Pphe(Rgenetics):
"""fake class to distinguish different species of Rgenetics data collections
"""
fake class to distinguish different species of Rgenetics data collections
"""
file_ext="pphe"
@@ -418,14 +398,15 @@ class Pphe(Rgenetics):
Rgenetics.__init__(self, **kwd)
self.add_composite_file( '%s.pphe', description = 'Plink Phenotype File', substitute_name_with_metadata = 'base_name' )
class Lmap(Rgenetics):
"""fake class to distinguish different species of Rgenetics data collections
"""
fake class to distinguish different species of Rgenetics data collections
"""
file_ext="lmap"
class Fphe(Rgenetics):
"""fake class to distinguish different species of Rgenetics data collections
"""
fake class to distinguish different species of Rgenetics data collections
"""
file_ext="fphe"
@@ -434,7 +415,8 @@ class Fphe(Rgenetics):
self.add_composite_file( '%s.fphe', description = 'FBAT Phenotype File', substitute_name_with_metadata = 'base_name' )
class Phe(Rgenetics):
"""fake class to distinguish different species of Rgenetics data collections
"""
fake class to distinguish different species of Rgenetics data collections
"""
file_ext="phe"
@@ -442,10 +424,9 @@ class Phe(Rgenetics):
Rgenetics.__init__(self, **kwd)
self.add_composite_file( '%s.phe', description = 'Phenotype File', substitute_name_with_metadata = 'base_name' )
class Fped(Rgenetics):
"""fake class to distinguish different species of Rgenetics data collections
"""
fake class to distinguish different species of Rgenetics data collections
"""
file_ext="fped"
@@ -453,9 +434,9 @@ class Fped(Rgenetics):
Rgenetics.__init__(self, **kwd)
self.add_composite_file( '%s.fped', description = 'FBAT format pedfile', substitute_name_with_metadata = 'base_name' )
class Pbed(Rgenetics):
"""fake class to distinguish different species of Rgenetics data collections
"""
fake class to distinguish different species of Rgenetics data collections
"""
file_ext="pbed"
@@ -466,7 +447,8 @@ class Pbed(Rgenetics):
self.add_composite_file( '%s.fam', substitute_name_with_metadata = 'base_name', is_binary = True )
class Eigenstratgeno(Rgenetics):
"""fake class to distinguish different species of Rgenetics data collections
"""
fake class to distinguish different species of Rgenetics data collections
"""
file_ext="eigenstratgeno"
@@ -475,11 +457,10 @@ class Eigenstratgeno(Rgenetics):
self.add_composite_file( '%s.eigenstratgeno', substitute_name_with_metadata = 'base_name', is_binary = True )
self.add_composite_file( '%s.ind', substitute_name_with_metadata = 'base_name', is_binary = True )
self.add_composite_file( '%s.map', substitute_name_with_metadata = 'base_name', is_binary = True )
class Eigenstratpca(Rgenetics):
"""fake class to distinguish different species of Rgenetics data collections
"""
fake class to distinguish different species of Rgenetics data collections
"""
file_ext="eigenstratpca"
@@ -487,22 +468,21 @@ class Eigenstratpca(Rgenetics):
Rgenetics.__init__(self, **kwd)
self.add_composite_file( '%s.eigenstratpca', description = 'Eigenstrat PCA file', substitute_name_with_metadata = 'base_name' )
class Snptest(Rgenetics):
"""fake class to distinguish different species of Rgenetics data collections
"""
fake class to distinguish different species of Rgenetics data collections
"""
file_ext="snptest"
class Pheno(Tabular):
"""
base class for pheno files
"""
file_ext = 'pheno'
class RexpBase( Html ):
"""base class for BioC data structures in Galaxy
"""
base class for BioC data structures in Galaxy
must be constructed with the pheno data in place since that
goes into the metadata for each instance
"""
@@ -518,18 +498,16 @@ class RexpBase( Html ):
composite_type = 'auto_primary_file'
allow_datatype_change = False
def __init__( self, **kwd ):
Html.__init__(self,**kwd)
self.add_composite_file( '%s.pheno', description = 'Phenodata tab text file',
substitute_name_with_metadata = 'base_name', is_binary=True)
def generate_primary_file( self, dataset = None ):
""" This is called only at upload to write the html file
"""
This is called only at upload to write the html file
cannot rename the datasets here - they come with the default unfortunately
"""
return '<html><head></head><body>AutoGenerated Primary File for Composite Dataset</body></html>'
def get_phecols(self, phenolist=[], maxConc=20):
"""
sept 2009: cannot use whitespace to split - make a more complex structure here
@@ -555,7 +533,7 @@ class RexpBase( Html ):
else:
for col,code in enumerate(row): # keep column order correct
if col >= totcols:
gal_Log.warning('### get_phecols error in pheno file - row %d col %d (%s) longer than header %s' % (nrows, col, row, head))
log.warning('### get_phecols error in pheno file - row %d col %d (%s) longer than header %s' % (nrows, col, row, head))
else:
concordance[col].setdefault(code,0) # first one is zero
concordance[col][code] += 1
@@ -601,10 +579,9 @@ class RexpBase( Html ):
res = [('no usable phenotype columns found',[('?',0),]),]
return res
def get_pheno(self,dataset):
"""expects a .pheno file in the extra_files_dir - ugh
"""
expects a .pheno file in the extra_files_dir - ugh
note that R is wierd and adds the row.name in
the header so the columns are all wrong - unless you tell it not to.
A file can be written as
@@ -620,11 +597,12 @@ class RexpBase( Html ):
else:
p = []
return '\n'.join(p)
def set_peek( self, dataset ):
"""expects a .pheno file in the extra_files_dir - ugh
"""
expects a .pheno file in the extra_files_dir - ugh
note that R is wierd and does not include the row.name in
the header. why?"""
the header. why?
"""
if not dataset.dataset.purged:
pp = os.path.join(dataset.extra_files_path,'%s.pheno' % dataset.metadata.base_name)
try:
@@ -636,17 +614,14 @@ class RexpBase( Html ):
else:
dataset.peek = 'file does not exist\n'
dataset.blurb = 'file purged from disk'
def get_peek( self, dataset ):
"""expects a .pheno file in the extra_files_dir - ugh
"""
"""expects a .pheno file in the extra_files_dir - ugh"""
pp = os.path.join(dataset.extra_files_path,'%s.pheno' % dataset.metadata.base_name)
try:
p = file(pp,'r').readlines()
except:
p = ['##failed to find %s' % pp]
return ''.join(p[:5])
def get_file_peek(self,filename):
"""
can't really peek at a filename - need the extra_files_path and such?
@@ -657,7 +632,6 @@ class RexpBase( Html ):
except:
pass
return ''.join(h[:5])
def regenerate_primary_file(self,dataset):
"""cannot do this until we are setting metadata
"""
@@ -672,24 +646,19 @@ class RexpBase( Html ):
f.write("\n".join( rval ))
f.write('\n')
f.close()
"""Add metadata elements"""
def init_meta( self, dataset, copy_from=None ):
"""Add metadata elements"""
if copy_from:
dataset.metadata = copy_from.metadata
def set_meta( self, dataset, **kwd ):
"""
NOTE we apply the tabular machinary to the phenodata extracted
from a BioC eSet or affybatch.
"""
try:
flist = os.listdir(dataset.extra_files_path)
except:
if verbose:
gal_Log.debug('@@@rexpression set_meta failed - no dataset?')
#log.debug('@@@rexpression set_meta failed - no dataset?')
return False
bn = None
for f in flist:
@@ -727,7 +696,6 @@ class RexpBase( Html ):
if not dataset.blurb:
dataset.blurb = 'R loadable BioC expression object for the Rexpression Galaxy toolkit'
return True
def make_html_table( self, pp='nothing supplied from peek\n'):
"""Create HTML table, used for displaying peek"""
out = ['<table cellspacing="0" cellpadding="3">',]
@@ -750,20 +718,16 @@ class RexpBase( Html ):
except Exception, exc:
out = "Can't create html table %s" % str( exc )
return out
def display_peek( self, dataset ):
"""Returns formatted html of peek"""
out=self.make_html_table(dataset.peek)
return out
def get_mime(self):
"""Returns the mime type of the datatype"""
return 'text/html'
class Affybatch( RexpBase ):
"""derived class for BioC data structures in Galaxy """
file_ext = "affybatch"
def __init__( self, **kwd ):
@@ -780,7 +744,6 @@ class Eset( RexpBase ):
self.add_composite_file( '%s.eset', description = 'ESet R object saved to file',
substitute_name_with_metadata = 'base_name', is_binary = True )
class MAlist( RexpBase ):
"""derived class for BioC data structures in Galaxy """
file_ext = "malist"
@@ -790,9 +753,6 @@ class MAlist( RexpBase ):
self.add_composite_file( '%s.malist', description = 'MAlist R object saved to file',
substitute_name_with_metadata = 'base_name', is_binary = True )
if __name__ == '__main__':
import doctest, sys
doctest.testmod(sys.modules[__name__])
lib/galaxy/datatypes/images.py
-120
View File
@@ -13,82 +13,6 @@ import os, subprocess, tempfile
log = logging.getLogger(__name__)
class Ab1( data.Data ):
"""Class describing an ab1 binary sequence file"""
file_ext = "ab1"
def set_peek( self, dataset ):
if not dataset.dataset.purged:
export_url = "/history_add_to?" + urlencode({'history_id':dataset.history_id,'ext':'ab1','name':'ab1 sequence','info':'Sequence file','dbkey':dataset.dbkey})
dataset.peek = "Binary ab1 sequence file"
dataset.blurb = data.nice_size( dataset.get_size() )
else:
dataset.peek = 'file does not exist'
dataset.blurb = 'file purged from disk'
def display_peek(self, dataset):
try:
return dataset.peek
except:
return "Binary ab1 sequence file (%s)" % ( data.nice_size( dataset.get_size() ) )
class Scf( data.Data ):
"""Class describing an scf binary sequence file"""
file_ext = "scf"
def set_peek( self, dataset ):
if not dataset.dataset.purged:
export_url = "/history_add_to?" + urlencode({'history_id':dataset.history_id,'ext':'scf','name':'scf sequence','info':'Sequence file','dbkey':dataset.dbkey})
dataset.peek = "Binary scf sequence file"
dataset.blurb = data.nice_size( dataset.get_size() )
else:
dataset.peek = 'file does not exist'
dataset.blurb = 'file purged from disk'
def display_peek(self, dataset):
try:
return dataset.peek
except:
return "Binary scf sequence file (%s)" % ( data.nice_size( dataset.get_size() ) )
class Binseq( data.Data ):
"""Class describing a zip archive of binary sequence files"""
file_ext = "binseq.zip"
def set_peek( self, dataset ):
if not dataset.dataset.purged:
zip_file = zipfile.ZipFile( dataset.file_name, "r" )
num_files = len( zip_file.namelist() )
dataset.peek = "Archive of %s binary sequence files" % ( str( num_files ) )
dataset.blurb = data.nice_size( dataset.get_size() )
else:
dataset.peek = 'file does not exist'
dataset.blurb = 'file purged from disk'
def display_peek(self, dataset):
try:
return dataset.peek
except:
return "Binary sequence file archive (%s)" % ( data.nice_size( dataset.get_size() ) )
def get_mime(self):
"""Returns the mime type of the datatype"""
return 'application/zip'
class Txtseq( data.Data ):
"""Class describing a zip archive of text sequence files"""
file_ext = "txtseq.zip"
def set_peek( self, dataset ):
if not dataset.dataset.purged:
zip_file = zipfile.ZipFile( dataset.file_name, "r" )
num_files = len( zip_file.namelist() )
dataset.peek = "Archive of %s text sequence files" % ( str( num_files ) )
dataset.blurb = data.nice_size( dataset.get_size() )
else:
dataset.peek = 'file does not exist'
dataset.blurb = 'file purged from disk'
def display_peek(self, dataset):
try:
return dataset.peek
except:
return "Text sequence file archive (%s)" % ( data.nice_size( dataset.get_size() ) )
def get_mime(self):
"""Returns the mime type of the datatype"""
return 'application/zip'
class Image( data.Data ):
"""Class describing an image"""
def set_peek( self, dataset ):
@@ -236,47 +160,3 @@ class Laj( data.Text ):
return dataset.peek
except:
return "peek unavailable"
class Bam( data.Binary ):
"""Class describing a BAM binary file"""
file_ext = "bam"
MetadataElement( name="bam_index", desc="BAM Index File", param=metadata.FileParameter, readonly=True, no_value=None, visible=False, optional=True )
def init_meta( self, dataset, copy_from=None ):
data.Binary.init_meta( self, dataset, copy_from=copy_from )
def set_meta( self, dataset, overwrite = True, **kwd ):
"""
Sets index for BAM file.
"""
index_file = dataset.metadata.bam_index
if not index_file:
index_file = dataset.metadata.spec['bam_index'].param.new_file( dataset = dataset )
tmp_dir = tempfile.gettempdir()
tmpf1 = tempfile.NamedTemporaryFile(dir=tmp_dir)
tmpf1bai = '%s.bai' % tmpf1.name
try:
os.system('cd %s' % tmp_dir)
os.system('cp %s %s' % (dataset.file_name, tmpf1.name))
os.system('samtools index %s' % tmpf1.name)
os.system('cp %s %s' % (tmpf1bai, index_file.file_name))
except Exception, ex:
sys.stderr.write('There was a problem creating the index for the BAM file\n%s\n' + str(ex))
tmpf1.close()
if os.path.exists(tmpf1bai):
os.remove(tmpf1bai)
dataset.metadata.bam_index = index_file
def set_peek( self, dataset ):
if not dataset.dataset.purged:
export_url = "/history_add_to?" + urlencode({'history_id':dataset.history_id,'ext':'bam','name':'bam alignments','info':'Alignments file','dbkey':dataset.dbkey})
dataset.peek = "Binary bam alignments file"
dataset.blurb = data.nice_size( dataset.get_size() )
else:
dataset.peek = 'file does not exist'
dataset.blurb = 'file purged from disk'
def display_peek(self, dataset):
try:
return dataset.peek
except:
return "Binary bam alignments file (%s)" % ( data.nice_size( dataset.get_size() ) )
def get_mime(self):
"""Returns the mime type of the datatype"""
return 'application/octet-stream'
lib/galaxy/datatypes/metadata.py
+2 -2
View File
@@ -509,7 +509,7 @@ class JobExternalOutputMetadataWrapper( object ):
# need to make different keys for them, since ids can overlap
return "%s_%d" % ( dataset.__class__.__name__, dataset.id )
def setup_external_metadata( self, datasets, sa_session, exec_dir=None, tmp_dir=None, dataset_files_path=None,
output_fnames=None, config_root=None, datatypes_config=None, kwds={} ):
output_fnames=None, config_root=None, datatypes_config=None, job_metadata=None, kwds={} ):
#fill in metadata_files_dict and return the command with args required to set metadata
def __metadata_files_list_to_cmd_line( metadata_files ):
def __get_filename_override():
@@ -564,7 +564,7 @@ class JobExternalOutputMetadataWrapper( object ):
sa_session.flush()
metadata_files_list.append( metadata_files )
#return command required to build
return "%s %s %s %s %s %s" % ( os.path.join( exec_dir, 'set_metadata.sh' ), dataset_files_path, tmp_dir, config_root, datatypes_config, " ".join( map( __metadata_files_list_to_cmd_line, metadata_files_list ) ) )
return "%s %s %s %s %s %s %s" % ( os.path.join( exec_dir, 'set_metadata.sh' ), dataset_files_path, tmp_dir, config_root, datatypes_config, job_metadata, " ".join( map( __metadata_files_list_to_cmd_line, metadata_files_list ) ) )
def external_metadata_set_successfully( self, dataset, sa_session ):
metadata_files = self.get_output_filenames_by_dataset( dataset, sa_session )
lib/galaxy/datatypes/registry.py
+8 -8
View File
@@ -3,7 +3,7 @@ Provides mapping between extensions and datatypes, mime-types, etc.
"""
import os, tempfile
import logging
import data, tabular, interval, images, sequence, qualityscore, genetics, xml, coverage, tracks, chrominfo
import data, tabular, interval, images, sequence, qualityscore, genetics, xml, coverage, tracks, chrominfo, binary
import galaxy.util
from galaxy.util.odict import odict
@@ -109,11 +109,11 @@ class Registry( object ):
#default values
if len(self.datatypes_by_extension) < 1:
self.datatypes_by_extension = {
'ab1' : images.Ab1(),
'ab1' : binary.Ab1(),
'axt' : sequence.Axt(),
'bam' : images.Bam(),
'bam' : binary.Bam(),
'bed' : interval.Bed(),
'binseq.zip' : images.Binseq(),
'binseq.zip' : binary.Binseq(),
'blastxml' : xml.BlastXml(),
'coverage' : coverage.LastzCoverage(),
'customtrack' : interval.CustomTrack(),
@@ -132,12 +132,12 @@ class Registry( object ):
'qualsolexa' : qualityscore.QualityScoreSolexa(),
'qual454' : qualityscore.QualityScore454(),
'sam' : tabular.Sam(),
'scf' : images.Scf(),
'sff' : data.Sff(),
'scf' : binary.Scf(),
'sff' : binary.Sff(),
'tabular' : tabular.Tabular(),
'taxonomy' : tabular.Taxonomy(),
'txt' : data.Text(),
'txtseq.zip' : images.Txtseq(),
'txtseq.zip' : data.Txtseq(),
'wig' : interval.Wiggle()
}
self.mimetypes_by_extension = {
@@ -174,7 +174,7 @@ class Registry( object ):
# because some formats are much more flexibly defined than others.
if len(self.sniff_order) < 1:
self.sniff_order = [
data.Sff(),
binary.Sff(),
xml.BlastXml(),
sequence.Maf(),
sequence.Lav(),
lib/galaxy/datatypes/tracks.py
+3 -6
View File
@@ -3,10 +3,7 @@ Datatype classes for tracks/track views within galaxy.
"""
import data
import logging
import re
import binascii
from cgi import escape
import tabular, binascii, logging
from galaxy.datatypes.metadata import MetadataElement
from galaxy.datatypes import metadata
import galaxy.model
@@ -17,7 +14,7 @@ from galaxy.util.hash_util import *
log = logging.getLogger(__name__)
class GeneTrack( data.Binary ):
class GeneTrack( tabular.Tabular ):
file_ext = "genetrack"
MetadataElement( name="genetrack", default="data.genetrack", desc="HDF index", readonly=True, visible=True, no_value=0 )
@@ -27,7 +24,7 @@ class GeneTrack( data.Binary ):
super( GeneTrack, self ).__init__( **kwargs )
self.add_display_app( 'genetrack', 'View in', '', 'genetrack_link' )
def get_display_links( self, dataset, type, app, base_url, target_frame='galaxy_main', **kwd ):
return data.Binary.get_display_links( self, dataset, type, app, base_url, target_frame=target_frame, **kwd )
return data.Data.get_display_links( self, dataset, type, app, base_url, target_frame=target_frame, **kwd )
def genetrack_link( self, hda, type, app, base_url ):
ret_val = []
if hda.has_data:
lib/galaxy/jobs/__init__.py
+15 -7
View File
@@ -139,10 +139,15 @@ class JobQueue( object ):
JobWrapper( job, None, self ).fail( 'This tool was disabled before the job completed. Please contact your Galaxy administrator, or' )
elif job.job_runner_name is None:
log.debug( "no runner: %s is still in queued state, adding to the jobs queue" %job.id )
self.queue.put( ( job.id, job.tool_id ) )
if self.track_jobs_in_database:
job.state = model.Job.states.NEW
else:
self.queue.put( ( job.id, job.tool_id ) )
else:
job_wrapper = JobWrapper( job, self.app.toolbox.tools_by_id[ job.tool_id ], self )
self.dispatcher.recover( job, job_wrapper )
if self.sa_session.dirty:
self.sa_session.flush()
def __monitor( self ):
"""
@@ -526,6 +531,7 @@ class JobWrapper( object ):
# If the tool was expected to set the extension, attempt to retrieve it
if dataset.ext == 'auto':
dataset.extension = context.get( 'ext', 'data' )
dataset.init_meta( copy_from=dataset )
#if a dataset was copied, it won't appear in our dictionary:
#either use the metadata from originating output dataset, or call set_meta on the copies
#it would be quicker to just copy the metadata from the originating output dataset,
@@ -715,14 +721,15 @@ class JobWrapper( object ):
for outfile in [ str( o ) for o in output_paths ]:
sizes.append( ( outfile, os.stat( outfile ).st_size ) )
return sizes
def setup_external_metadata( self, exec_dir = None, tmp_dir = None, dataset_files_path = None, config_root = None, datatypes_config = None, **kwds ):
def setup_external_metadata( self, exec_dir = None, tmp_dir = None, dataset_files_path = None, config_root = None, datatypes_config = None, set_extension = True, **kwds ):
# extension could still be 'auto' if this is the upload tool.
job = self.sa_session.query( model.Job ).get( self.job_id )
for output_dataset_assoc in job.output_datasets:
if output_dataset_assoc.dataset.ext == 'auto':
context = self.get_dataset_finish_context( dict(), output_dataset_assoc.dataset.dataset )
output_dataset_assoc.dataset.extension = context.get( 'ext', 'data' )
self.sa_session.flush()
if set_extension:
for output_dataset_assoc in job.output_datasets:
if output_dataset_assoc.dataset.ext == 'auto':
context = self.get_dataset_finish_context( dict(), output_dataset_assoc.dataset.dataset )
output_dataset_assoc.dataset.extension = context.get( 'ext', 'data' )
self.sa_session.flush()
if tmp_dir is None:
#this dir should should relative to the exec_dir
tmp_dir = self.app.config.new_file_path
@@ -739,6 +746,7 @@ class JobWrapper( object ):
dataset_files_path = dataset_files_path,
config_root = config_root,
datatypes_config = datatypes_config,
job_metadata = os.path.join( self.working_directory, TOOL_PROVIDED_JOB_METADATA_FILE ),
**kwds )
class DefaultJobDispatcher( object ):
lib/galaxy/jobs/runners/local.py
+3 -1
View File
@@ -106,7 +106,9 @@ class LocalJobRunner( object ):
#this is terminatable when output dataset/job is deleted
#so that long running set_meta()s can be cancelled without having to reboot the server
if job_wrapper.get_state() not in [ model.Job.states.ERROR, model.Job.states.DELETED ] and self.app.config.set_metadata_externally and job_wrapper.output_paths:
external_metadata_script = job_wrapper.setup_external_metadata( output_fnames = job_wrapper.get_output_fnames(), kwds = { 'overwrite' : False } ) #we don't want to overwrite metadata that was copied over in init_meta(), as per established behavior
external_metadata_script = job_wrapper.setup_external_metadata( output_fnames = job_wrapper.get_output_fnames(),
set_extension = True,
kwds = { 'overwrite' : False } ) #we don't want to overwrite metadata that was copied over in init_meta(), as per established behavior
log.debug( 'executing external set_meta script for job %d: %s' % ( job_wrapper.job_id, external_metadata_script ) )
external_metadata_proc = subprocess.Popen( args = external_metadata_script,
shell = True,
lib/galaxy/jobs/runners/pbs.py
+11 -6
View File
@@ -29,7 +29,6 @@ if [ "$GALAXY_LIB" != "None" ]; then
fi
cd %s
%s
%s
"""
pbs_symlink_template = """#!/bin/sh
@@ -178,7 +177,9 @@ class PBSJobRunner( object ):
pbs_queue_name = self.determine_pbs_queue( runner_url )
c = pbs.pbs_connect( pbs_server_name )
if c <= 0:
raise Exception( "Connection to PBS server for submit failed" )
job_wrapper.fail( "Unable to queue job for execution. Resubmitting the job may succeed." )
log.error( "Connection to PBS server for submit failed" )
return
# define job attributes
ofile = "%s/%s.o" % (self.app.config.cluster_files_directory, job_wrapper.job_id)
@@ -221,11 +222,15 @@ class PBSJobRunner( object ):
if self.app.config.pbs_stage_path != '':
script = pbs_symlink_template % (job_wrapper.galaxy_lib_dir, " ".join(job_wrapper.get_input_fnames() + output_files), self.app.config.pbs_stage_path, exec_dir, command_line)
else:
script = pbs_template % ( job_wrapper.galaxy_lib_dir, exec_dir, command_line )
if self.app.config.set_metadata_externally:
external_metadata_script = job_wrapper.setup_external_metadata( exec_dir = os.path.abspath( os.getcwd() ), tmp_dir = self.app.config.new_file_path, dataset_files_path = self.app.model.Dataset.file_path, output_fnames = output_fnames, kwds = { 'overwrite' : False } ) #we don't want to overwrite metadata that was copied over in init_meta(), as per established behavior
else:
external_metadata_script = ""
script = pbs_template % ( job_wrapper.galaxy_lib_dir, exec_dir, command_line, external_metadata_script )
script += "cd %s\n" % os.path.abspath( os.getcwd() )
script += "%s\n" % job_wrapper.setup_external_metadata( exec_dir = os.path.abspath( os.getcwd() ),
tmp_dir = self.app.config.new_file_path,
dataset_files_path = self.app.model.Dataset.file_path,
output_fnames = output_fnames,
set_extension = False,
kwds = { 'overwrite' : False } ) #we don't want to overwrite metadata that was copied over in init_meta(), as per established behavior
job_file = "%s/%s.sh" % (self.app.config.cluster_files_directory, job_wrapper.job_id)
fh = file(job_file, "w")
fh.write(script)
lib/galaxy/tools/actions/metadata.py
+1
View File
@@ -41,6 +41,7 @@ class SetMetadataToolAction( ToolAction ):
output_fnames = None,
config_root = None,
datatypes_config = None,
job_metadata = None,
kwds = { 'overwrite' : True } )
incoming[ '__SET_EXTERNAL_METADATA_COMMAND_LINE__' ] = cmd_line
for name, value in tool.params_to_strings( incoming, trans.app ).iteritems():
lib/galaxy/web/controllers/dataset.py
+39 -22
View File
@@ -20,25 +20,38 @@ GALAXY TOOL ERROR REPORT
This error report was sent from the Galaxy instance hosted on the server
"${host}"
-----------------------------------------------------------------------------
This is in reference to output dataset ${dataset_id}.
This is in reference to dataset id ${dataset_id} from history id ${history_id}
-----------------------------------------------------------------------------
You should be able to view the history containing the related history item
${hid}: ${history_item_name}
by logging in as a Galaxy admin user to the Galaxy instance referenced above
and pointing your browser to the following link.
${history_view_link}
-----------------------------------------------------------------------------
The user '${email}' provided the following information:
${message}
-----------------------------------------------------------------------------
job id: ${job_id}
tool id: ${tool_id}
tool id: ${job_tool_id}
-----------------------------------------------------------------------------
job command line:
${job_command_line}
-----------------------------------------------------------------------------
job stderr:
${stderr}
${job_stderr}
-----------------------------------------------------------------------------
job stdout:
${stdout}
${job_stdout}
-----------------------------------------------------------------------------
job info:
${info}
${job_info}
-----------------------------------------------------------------------------
job traceback:
${traceback}
${job_traceback}
-----------------------------------------------------------------------------
(This is an automated message).
"""
@@ -103,41 +116,45 @@ class DatasetInterface( BaseController ):
@web.expose
def errors( self, trans, id ):
dataset = trans.sa_session.query( model.HistoryDatasetAssociation ).get( id )
return trans.fill_template( "dataset/errors.mako", dataset=dataset )
hda = trans.sa_session.query( model.HistoryDatasetAssociation ).get( id )
return trans.fill_template( "dataset/errors.mako", hda=hda )
@web.expose
def stderr( self, trans, id ):
dataset = trans.sa_session.query( model.HistoryDatasetAssociation ).get( id )
job = dataset.creating_job_associations[0].job
trans.response.set_content_type( 'text/plain' )
return job.stderr
@web.expose
def report_error( self, trans, id, email='', message="" ):
smtp_server = trans.app.config.smtp_server
if smtp_server is None:
return trans.show_error_message( "Sorry, mail is not configured for this galaxy instance" )
return trans.show_error_message( "Mail is not configured for this galaxy instance" )
to_address = trans.app.config.error_email_to
if to_address is None:
return trans.show_error_message( "Sorry, error reporting has been disabled for this galaxy instance" )
return trans.show_error_message( "Error reporting has been disabled for this galaxy instance" )
# Get the dataset and associated job
dataset = trans.sa_session.query( model.HistoryDatasetAssociation ).get( id )
job = dataset.creating_job_associations[0].job
hda = trans.sa_session.query( model.HistoryDatasetAssociation ).get( id )
job = hda.creating_job_associations[0].job
# Get the name of the server hosting the Galaxy instance from which this report originated
host = trans.request.host
history_view_link = "%s/history/view?id=%s" % ( str( host ), trans.security.encode_id( hda.history_id ) )
# Build the email message
msg = MIMEText( string.Template( error_report_template )
.safe_substitute( host=host,
dataset_id=dataset.id,
email=email,
message=message,
dataset_id=hda.dataset_id,
history_id=hda.history_id,
hid=hda.hid,
history_item_name=hda.get_display_name(),
history_view_link=history_view_link,
job_id=job.id,
tool_id=job.tool_id,
stderr=job.stderr,
stdout=job.stdout,
traceback=job.traceback,
info=job.info ) )
job_tool_id=job.tool_id,
job_command_line=job.command_line,
job_stderr=job.stderr,
job_stdout=job.stdout,
job_info=job.info,
job_traceback=job.traceback,
email=email,
message=message ) )
frm = to_address
# Check email a bit
email = email.strip()
lib/galaxy/web/controllers/forms.py
+158 -94
View File
@@ -8,9 +8,71 @@ from galaxy.tools.parameters.basic import parameter_types
from elementtree.ElementTree import XML, Element
from galaxy.util.odict import odict
import copy
from galaxy.web.framework.helpers import time_ago, iff, grids
log = logging.getLogger( __name__ )
class FormsGrid( grids.Grid ):
# Custom column types
class NameColumn( grids.TextColumn ):
def get_value(self, trans, grid, form):
return form.latest_form.name
class DescriptionColumn( grids.TextColumn ):
def get_value(self, trans, grid, form):
return form.latest_form.desc
class TypeColumn( grids.TextColumn ):
def get_value(self, trans, grid, form):
return form.latest_form.type
class DeletedColumn( grids.GridColumn ):
def get_accepted_filters( self ):
""" Returns a list of accepted filters for this column. """
accepted_filter_labels_and_vals = { "active" : "False", "deleted" : "True", "all": "All" }
accepted_filters = []
for label, val in accepted_filter_labels_and_vals.items():
args = { self.key: val }
accepted_filters.append( grids.GridColumnFilter( label, args) )
return accepted_filters
# Grid definition
title = "Forms"
template = "admin/forms/grid.mako"
model_class = model.FormDefinitionCurrent
default_sort_key = "-create_time"
num_rows_per_page = 50
preserve_state = True
use_paging = True
default_filter = dict( deleted="False" )
columns = [
NameColumn( "Name",
key="name",
model_class=model.FormDefinition,
link=( lambda item: iff( item.deleted, None, dict( operation="view", id=item.id ) ) ),
attach_popup=True,
filterable="advanced" ),
DescriptionColumn( "Description",
key='desc',
model_class=model.FormDefinition,
filterable="advanced" ),
TypeColumn( "Type" ),
DeletedColumn( "Deleted",
key="deleted",
visible=False,
filterable="advanced" )
]
columns.append( grids.MulticolFilterColumn( "Search",
cols_to_filter=[ columns[0], columns[1] ],
key="free-text-search",
visible=False,
filterable="standard" ) )
operations = [
grids.GridOperation( "Edit", allow_multiple=False, condition=( lambda item: not item.deleted ) ),
grids.GridOperation( "Delete", allow_multiple=True, condition=( lambda item: not item.deleted ) ),
grids.GridOperation( "Undelete", condition=( lambda item: item.deleted ) ),
]
global_actions = [
grids.GridAction( "Create new form", dict( controller='forms',
action='new' ) )
]
class Forms( BaseController ):
# Empty form field
empty_field = { 'label': '',
@@ -20,38 +82,38 @@ class Forms( BaseController ):
'type': BaseField.form_field_types()[0],
'selectlist': [],
'layout': 'none' }
forms_grid = FormsGrid()
@web.expose
@web.require_admin
def index( self, trans, **kwd ):
params = util.Params( kwd )
msg = util.restore_text( params.get( 'msg', '' ) )
messagetype = params.get( 'messagetype', 'done' )
return trans.fill_template( "/sample/index.mako",
default_action=params.get( 'default_action', None ),
msg=msg,
messagetype=messagetype )
@web.expose
@web.require_admin
def manage( self, trans, **kwd ):
params = util.Params( kwd )
msg = util.restore_text( params.get( 'msg', '' ) )
messagetype = params.get( 'messagetype', 'done' )
show_filter = params.get( 'show_filter', 'Active' )
return self._show_forms_list(trans, msg, messagetype, show_filter)
def _show_forms_list(self, trans, msg, messagetype, show_filter='Active'):
all_forms = trans.sa_session.query( trans.app.model.FormDefinitionCurrent )
if show_filter == 'All':
forms_list = all_forms
elif show_filter == 'Deleted':
forms_list = [form for form in all_forms if form.deleted]
else:
forms_list = [form for form in all_forms if not form.deleted]
return trans.fill_template( '/admin/forms/manage_forms.mako',
fdc_list=forms_list,
all_forms=all_forms,
show_filter=show_filter,
msg=msg,
messagetype=messagetype )
def manage( self, trans, **kwd ):
if 'operation' in kwd:
operation = kwd['operation'].lower()
if not kwd.get( 'id', None ):
return trans.response.send_redirect( web.url_for( controller='forms',
action='manage',
status='error',
message="Invalid form ID") )
if operation == "view":
return self.__view( trans, **kwd )
elif operation == "delete":
return self.__delete( trans, **kwd )
elif operation == "undelete":
return self.__undelete( trans, **kwd )
elif operation == "edit":
return self.__edit( trans, **kwd )
return self.forms_grid( trans, **kwd )
def __view(self, trans, **kwd):
try:
fdc = trans.sa_session.query( trans.app.model.FormDefinitionCurrent )\
.get( trans.security.decode_id(kwd['id']) )
except:
return trans.response.send_redirect( web.url_for( controller='forms',
action='manage',
msg='Invalid form',
messagetype='error' ) )
return trans.fill_template( '/admin/forms/show_form_read_only.mako',
form=fdc.latest_form )
def __form_types_widget(self, trans, selected='none'):
form_type_selectbox = SelectField( 'form_type_selectbox',
refresh_on_change=True,
@@ -86,13 +148,14 @@ class Forms( BaseController ):
self.__get_saved_form( fd )
if self.__imported_from_file:
return trans.response.send_redirect( web.url_for( controller='forms',
action='edit',
show_form=True,
form_id=fd.id) )
action='manage',
operation='edit',
id=trans.security.encode_id(fd.current.id)) )
else:
return trans.response.send_redirect( web.url_for( controller='forms',
action='edit',
form_id=fd.id,
action='manage',
operation='edit',
id=trans.security.encode_id(fd.current.id),
add_field_button='Add field',
name=fd.name,
description=fd.desc,
@@ -105,35 +168,43 @@ class Forms( BaseController ):
inputs=inputs,
msg=msg,
messagetype=messagetype )
@web.expose
@web.require_admin
def delete( self, trans, **kwd ):
params = util.Params( kwd )
msg = util.restore_text( params.get( 'msg', '' ) )
messagetype = params.get( 'messagetype', 'done' )
fd = trans.sa_session.query( trans.app.model.FormDefinition ).get( int( util.restore_text( params.form_id ) ) )
fd.form_definition_current.deleted = True
trans.sa_session.add( fd.form_definition_current )
trans.sa_session.flush()
return self._show_forms_list(trans,
msg='The form definition named %s is deleted.' % fd.name,
messagetype='done')
@web.expose
@web.require_admin
def undelete( self, trans, **kwd ):
params = util.Params( kwd )
msg = util.restore_text( params.get( 'msg', '' ) )
messagetype = params.get( 'messagetype', 'done' )
fd = trans.sa_session.query( trans.app.model.FormDefinition ).get( int( util.restore_text( params.form_id ) ) )
fd.form_definition_current.deleted = False
trans.sa_session.add( fd.form_definition_current )
trans.sa_session.flush()
return self._show_forms_list(trans,
msg='The form definition named %s is undeleted.' % fd.name,
messagetype='done')
@web.expose
@web.require_admin
def edit( self, trans, **kwd ):
def __delete( self, trans, **kwd ):
id_list = util.listify( kwd['id'] )
delete_failed = []
for id in id_list:
try:
fdc = trans.sa_session.query( trans.app.model.FormDefinitionCurrent ).get( trans.security.decode_id(id) )
except:
return trans.response.send_redirect( web.url_for( controller='forms',
action='manage',
message='Invalid form',
status='error' ) )
fdc.deleted = True
trans.sa_session.add( fdc )
trans.sa_session.flush()
return trans.response.send_redirect( web.url_for( controller='forms',
action='manage',
message='%i form(s) is deleted.' % len(id_list),
status='done') )
def __undelete( self, trans, **kwd ):
id_list = util.listify( kwd['id'] )
delete_failed = []
for id in id_list:
try:
fdc = trans.sa_session.query( trans.app.model.FormDefinitionCurrent ).get( trans.security.decode_id(id) )
except:
return trans.response.send_redirect( web.url_for( controller='forms',
action='manage',
message='Invalid form',
status='error' ) )
fdc.deleted = False
trans.sa_session.add( fdc )
trans.sa_session.flush()
return trans.response.send_redirect( web.url_for( controller='forms',
action='manage',
message='%i form(s) is undeleted.' % len(id_list),
status='done') )
def __edit( self, trans, **kwd ):
'''
This callback method is for handling all the editing functions like
renaming fields, adding/deleting fields, changing fields attributes.
@@ -142,17 +213,28 @@ class Forms( BaseController ):
msg = util.restore_text( params.get( 'msg', '' ) )
messagetype = params.get( 'messagetype', 'done' )
try:
fd = trans.sa_session.query( trans.app.model.FormDefinition ).get( int( params.get( 'form_id', None ) ) )
fdc = trans.sa_session.query( trans.app.model.FormDefinitionCurrent ).get( trans.security.decode_id(kwd['id']) )
except:
return trans.response.send_redirect( web.url_for( controller='forms',
action='manage',
msg='Invalid form',
messagetype='error' ) )
message='Invalid form',
status='error' ) )
fd = fdc.latest_form
#
# Show the form for editing
# Save changes
#
if params.get( 'show_form', False ):
if params.get( 'save_changes_button', False ):
fd_new, msg = self.__save_form( trans, fdc_id=fd.form_definition_current.id, **kwd )
# if validation error encountered while saving the form, show the
# unsaved form, with the error message
if not fd_new:
current_form = self.__get_form( trans, **kwd )
return self.__show( trans=trans, form=fd, current_form=current_form,
msg=msg, messagetype='error', **kwd )
# everything went fine. form saved successfully. Show the saved form
fd = fd_new
current_form = self.__get_saved_form( fd )
msg = "The form '%s' has been updated with the changes." % fd.name
return self.__show( trans=trans, form=fd, current_form=current_form,
msg=msg, messagetype=messagetype, **kwd )
#
@@ -193,31 +275,6 @@ class Forms( BaseController ):
return self.__show( trans=trans, form=fd, current_form=current_form,
msg=msg, messagetype=messagetype, **kwd )
#
# Save changes
#
elif params.get( 'save_changes_button', False ):
fd_new, msg = self.__save_form( trans, fdc_id=fd.form_definition_current.id, **kwd )
# if validation error encountered while saving the form, show the
# unsaved form, with the error message
if not fd_new:
current_form = self.__get_form( trans, **kwd )
return self.__show( trans=trans, form=fd, current_form=current_form,
msg=msg, messagetype='error', **kwd )
# everything went fine. form saved successfully. Show the saved form
fd = fd_new
current_form = self.__get_saved_form( fd )
msg = "The form '%s' has been updated with the changes." % fd.name
return self.__show( trans=trans, form=fd, current_form=current_form,
msg=msg, messagetype=messagetype, **kwd )
#
# Show form read-only
#
elif params.get( 'read_only', False ):
return trans.fill_template( '/admin/forms/show_form_read_only.mako',
form=fd,
msg=msg,
messagetype=messagetype )
#
# Add SelectField option
#
elif 'Add' in kwd.values():
@@ -234,6 +291,13 @@ class Forms( BaseController ):
current_form = self.__get_form( trans, **kwd )
return self.__show( trans=trans, form=fd, current_form=current_form,
msg=msg, messagetype=messagetype, **kwd )
#
# Show the form for editing
#
else:
current_form = self.__get_saved_form( fd )
return self.__show( trans=trans, form=fd, current_form=current_form,
msg=msg, messagetype=messagetype, **kwd )
def __add_selectbox_option( self, trans, fd, msg, messagetype, **kwd ):
'''
lib/galaxy/web/controllers/history.py
+15 -19
View File
@@ -87,7 +87,7 @@ class HistoryListGrid( grids.Grid ):
# Grid definition
title = "Saved Histories"
model_class = model.History
template='/history/grid.mako'
template='/grid_base.mako'
default_sort_key = "-create_time"
columns = [
NameColumn( "Name", key="name", model_class=model.History,
@@ -110,14 +110,14 @@ class HistoryListGrid( grids.Grid ):
)
operations = [
grids.GridOperation( "Switch", allow_multiple=False, condition=( lambda item: not item.deleted ) ),
grids.GridOperation( "Share", condition=( lambda item: not item.deleted ) ),
grids.GridOperation( "Unshare", condition=( lambda item: not item.deleted ) ),
grids.GridOperation( "Rename", condition=( lambda item: not item.deleted ) ),
grids.GridOperation( "Delete", condition=( lambda item: not item.deleted ) ),
grids.GridOperation( "Undelete", condition=( lambda item: item.deleted ) ),
grids.GridOperation( "Enable import via link", condition=( lambda item: item.deleted ) ),
grids.GridOperation( "Disable import via link", condition=( lambda item: item.deleted ) )
grids.GridOperation( "Switch", allow_multiple=False, condition=( lambda item: not item.deleted ), async_compatible=True ),
grids.GridOperation( "Share", condition=( lambda item: not item.deleted ), async_compatible=False ),
grids.GridOperation( "Unshare", condition=( lambda item: not item.deleted ), async_compatible=False ),
grids.GridOperation( "Rename", condition=( lambda item: not item.deleted ), async_compatible=False ),
grids.GridOperation( "Delete", condition=( lambda item: not item.deleted ), async_compatible=True ),
grids.GridOperation( "Undelete", condition=( lambda item: item.deleted ), async_compatible=True ),
grids.GridOperation( "Enable import via link", condition=( lambda item: item.deleted ), async_compatible=True ),
grids.GridOperation( "Disable import via link", condition=( lambda item: item.deleted ), async_compatible=True )
]
standard_filters = [
grids.GridColumnFilter( "Active", args=dict( deleted=False ) ),
@@ -262,7 +262,7 @@ class HistoryController( BaseController ):
n_deleted += 1
status = SUCCESS
if n_deleted:
message_parts.append( "Deleted %d histories. " % n_deleted )
message_parts.append( "Deleted %d %s. " % ( n_deleted, iff( n_deleted != 1, "histories", "history" ) ) )
if deleted_current:
message_parts.append( "Your active history was deleted, a new empty history is now active. " )
status = INFO
@@ -290,7 +290,7 @@ class HistoryController( BaseController ):
status = SUCCESS
message_parts = []
if n_undeleted:
message_parts.append( "Undeleted %d histories." % n_undeleted )
message_parts.append( "Undeleted %d %s. " % ( n_undeleted, iff( n_undeleted != 1, "histories", "history" ) ) )
if n_already_purged:
message_parts.append( "%d histories have already been purged and cannot be undeleted." % n_already_purged )
status = WARNING
@@ -438,23 +438,20 @@ class HistoryController( BaseController ):
Warning! If you import this history, you will lose your current
history. Click <a href="%s">here</a> to confirm.
""" % web.url_for( id=id, confirm=True ) )
@web.expose
def view( self, trans, id=None ):
"""View a history. If a history is importable, then it is viewable by any user."""
# Get history to view.
if not id:
return trans.show_error_message( "You must specify a history you want to view." )
history_to_view = get_history( trans, id, False)
# Integrity checks.
if not history_to_view:
return trans.show_error_message( "The specified history does not exist.")
return trans.show_error_message( "The specified history does not exist." )
# Admin users can view any history
# TODO: Use a new flag to determine if history is viewable?
if not history_to_view.importable:
error( "The owner of this history has not published this history." )
if not trans.user_is_admin and not history_to_view.importable:
error( "Either you are not allowed to view this history or the owner of this history has not published it." )
# View history.
query = trans.sa_session.query( model.HistoryDatasetAssociation ) \
.filter( model.HistoryDatasetAssociation.history == history_to_view ) \
@@ -469,7 +466,6 @@ class HistoryController( BaseController ):
datasets = query.all(),
user_owns_history = user_owns_history,
show_deleted = False )
@web.expose
@web.require_login( "share histories with other users" )
def share( self, trans, id=None, email="", **kwd ):
lib/galaxy/web/controllers/library_common.py
+1 -1
View File
@@ -117,7 +117,7 @@ class LibraryCommon( BaseController ):
uploaded_dataset.link_data_only = True
uploaded_dataset.data.file_name = os.path.abspath( path )
trans.sa_session.add( uploaded_dataset.data )
trans.sa_session.data.flush()
trans.sa_session.flush()
return uploaded_dataset
def get_server_dir_uploaded_datasets( self, trans, params, full_dir, import_dir_desc, library_bunch, err_redirect, msg ):
files = []
lib/galaxy/web/controllers/page.py
+54 -6
View File
@@ -1,6 +1,7 @@
from galaxy.web.base.controller import *
from galaxy.web.framework.helpers import time_ago, grids
from galaxy.util.sanitize_html import sanitize_html
from galaxy.util.odict import odict
import re
@@ -69,21 +70,66 @@ class PageAllPublishedGrid( grids.Grid ):
]
def apply_default_filter( self, trans, query, **kwargs ):
return query.filter_by( deleted=False, published=True )
class NameColumn( grids.TextColumn ):
def get_value(self, trans, grid, history):
return history.get_display_name()
class HistorySelectionGrid( grids.Grid ):
# Custom columns.
class NameColumn( grids.TextColumn ):
def get_value(self, trans, grid, history):
return history.get_display_name()
class DeletedColumn( grids.GridColumn ):
def get_accepted_filters( self ):
""" Returns a list of accepted filters for this column. """
accepted_filter_labels_and_vals = { "active" : "False", "deleted" : "True", "all": "All" }
accepted_filters = []
for label, val in accepted_filter_labels_and_vals.items():
args = { self.key: val }
accepted_filters.append( grids.GridColumnFilter( label, args) )
return accepted_filters
class SharingColumn( grids.GridColumn ):
def filter( self, db_session, query, column_filter ):
""" Modify query to filter histories by sharing status. """
if column_filter == "All":
pass
elif column_filter:
if column_filter == "private":
query = query.filter( model.History.users_shared_with == None )
query = query.filter( model.History.importable == False )
elif column_filter == "shared":
query = query.filter( model.History.users_shared_with != None )
elif column_filter == "importable":
query = query.filter( model.History.importable == True )
return query
def get_accepted_filters( self ):
""" Returns a list of accepted filters for this column. """
accepted_filter_labels_and_vals = odict()
accepted_filter_labels_and_vals["private"] = "private"
accepted_filter_labels_and_vals["shared"] = "shared"
accepted_filter_labels_and_vals["importable"] = "importable"
accepted_filter_labels_and_vals["all"] = "All"
accepted_filters = []
for label, val in accepted_filter_labels_and_vals.items():
args = { self.key: val }
accepted_filters.append( grids.GridColumnFilter( label, args) )
return accepted_filters
# Grid definition.
title = "Saved Histories"
template = "grid_base_async.mako"
async_template = "grid_body_async.mako"
model_class = model.History
default_filter = { "deleted" : "False" , "shared" : "All" }
default_sort_key = "-update_time"
use_paging = True
num_rows_per_page = 5
columns = [
NameColumn( "Name", key="name", model_class=model.History, filterable="advanced" ),
grids.TagsColumn( "Tags", "tags", model.History, model.HistoryTagAssociation, filterable="advanced"),
grids.GridColumn( "Last Updated", key="update_time", format=time_ago ),
# Columns that are valid for filtering but are not visible.
DeletedColumn( "Deleted", key="deleted", visible=False, filterable="advanced" ),
SharingColumn( "Shared", key="shared", visible=False, filterable="advanced" ),
]
columns.append(
grids.MulticolFilterColumn(
@@ -91,6 +137,8 @@ class HistorySelectionGrid( grids.Grid ):
cols_to_filter=[ columns[0], columns[1] ],
key="free-text-search", visible=False, filterable="standard" )
)
def apply_default_filter( self, trans, query, **kwargs ):
return query.filter_by( user=trans.user, purged=False )
class PageController( BaseController ):
@@ -268,4 +316,4 @@ class PageController( BaseController ):
@web.require_login("select a history from saved histories")
def list_histories_for_selection( self, trans, **kwargs ):
# Render the list view
return self._history_selection_grid( trans, status=status, message=message, **kwargs )
return self._history_selection_grid( trans, **kwargs )
lib/galaxy/web/controllers/requests.py
+174 -128
View File
@@ -12,57 +12,109 @@ from cgi import escape, FieldStorage
log = logging.getLogger( __name__ )
class RequestsListGrid( grids.Grid ):
class RequestsGrid( grids.Grid ):
# Custom column types
class NameColumn( grids.TextColumn ):
def get_value(self, trans, grid, request):
return request.name
class DescriptionColumn( grids.TextColumn ):
def get_value(self, trans, grid, request):
return request.desc
class SamplesColumn( grids.GridColumn ):
def get_value(self, trans, grid, request):
return str(len(request.samples))
class TypeColumn( grids.TextColumn ):
def get_value(self, trans, grid, request):
return request.type.name
class LastUpdateColumn( grids.TextColumn ):
def get_value(self, trans, grid, request):
return request.update_time
class StateColumn( grids.GridColumn ):
def filter( self, db_session, query, column_filter ):
""" Modify query to filter request by state. """
if column_filter == "All":
return query
if column_filter:
query = query.filter( model.Request.state == column_filter )
return query
def get_accepted_filters( self ):
""" Returns a list of accepted filters for this column. """
accepted_filter_labels_and_vals = [ model.Request.states.UNSUBMITTED,
model.Request.states.SUBMITTED,
model.Request.states.COMPLETE,
"All"]
accepted_filters = []
for val in accepted_filter_labels_and_vals:
label = val.lower()
args = { self.key: val }
accepted_filters.append( grids.GridColumnFilter( label, args) )
return accepted_filters
class DeletedColumn( grids.GridColumn ):
def get_accepted_filters( self ):
""" Returns a list of accepted filters for this column. """
accepted_filter_labels_and_vals = { "active" : "False", "deleted" : "True", "all": "All" }
accepted_filters = []
for label, val in accepted_filter_labels_and_vals.items():
args = { self.key: val }
accepted_filters.append( grids.GridColumnFilter( label, args) )
return accepted_filters
# Grid definition
title = "Sequencing Requests"
template = '/requests/grid.mako'
template = 'requests/grid.mako'
model_class = model.Request
default_sort_key = "-create_time"
show_filter = model.Request.states.UNSUBMITTED
num_rows_per_page = 50
preserve_state = True
use_paging = True
default_filter = dict( deleted="False", state=model.Request.states.UNSUBMITTED)
columns = [
grids.GridColumn( "Name", key="name",
link=( lambda item: iff( item.deleted, None, dict( operation="show_request", id=item.id ) ) ),
attach_popup=True ),
grids.GridColumn( "Description", key='desc'),
grids.GridColumn( "Sample(s)", method='number_of_samples',
link=( lambda item: iff( item.deleted, None, dict( operation="show_request", id=item.id ) ) ), ),
grids.GridColumn( "Type", key="request_type_id", method='get_request_type'),
grids.GridColumn( "Last update", key="update_time", format=time_ago ),
grids.GridColumn( "State", key='state'),
NameColumn( "Name",
key="name",
model_class=model.Request,
link=( lambda item: iff( item.deleted, None, dict( operation="show_request", id=item.id ) ) ),
attach_popup=True,
filterable="advanced" ),
DescriptionColumn( "Description",
key='desc',
model_class=model.Request,
filterable="advanced" ),
SamplesColumn( "Sample(s)",
link=( lambda item: iff( item.deleted, None, dict( operation="show_request", id=item.id ) ) ), ),
TypeColumn( "Type" ),
LastUpdateColumn( "Last update",
format=time_ago ),
StateColumn( "State",
key='state',
filterable="advanced"),
DeletedColumn( "Deleted",
key="deleted",
visible=True,
filterable="advanced" )
]
columns.append( grids.MulticolFilterColumn( "Search",
cols_to_filter=[ columns[0], columns[1] ],
key="free-text-search",
visible=False,
filterable="standard" ) )
operations = [
grids.GridOperation( "Submit", allow_multiple=False, condition=( lambda item: not item.deleted and item.unsubmitted() and item.samples ) ),
grids.GridOperation( "Edit", allow_multiple=False, condition=( lambda item: not item.deleted and item.unsubmitted() ) ),
grids.GridOperation( "Delete", allow_multiple=False, condition=( lambda item: not item.deleted and item.unsubmitted() ) ),
grids.GridOperation( "Undelete", allow_multiple=False, condition=( lambda item: item.deleted ) )
grids.GridOperation( "Delete", allow_multiple=True, condition=( lambda item: not item.deleted and item.unsubmitted() ) ),
grids.GridOperation( "Undelete", allow_multiple=True, condition=( lambda item: item.deleted ) )
]
standard_filters = [
grids.GridColumnFilter( model.Request.states.UNSUBMITTED,
args=dict( state=model.Request.states.UNSUBMITTED, deleted=False ) ),
grids.GridColumnFilter( model.Request.states.SUBMITTED,
args=dict( state=model.Request.states.SUBMITTED, deleted=False ) ),
grids.GridColumnFilter( model.Request.states.COMPLETE, args=dict( state=model.Request.states.COMPLETE, deleted=False ) ),
grids.GridColumnFilter( "Deleted", args=dict( deleted=True ) ),
grids.GridColumnFilter( "All", args={} )
global_actions = [
grids.GridAction( "Create new request", dict( controller='requests',
action='new',
select_request_type='True' ) )
]
#default_filter = dict( deleted=False )
def get_current_item( self, trans ):
return None
def get_request_type(self, trans, request):
return request.type.name
def apply_default_filter( self, trans, query, **kwargs ):
query = query.filter_by( user=trans.user )
if self.default_filter:
return query.filter_by( **self.default_filter )
else:
return query
def number_of_samples(self, trans, request):
return str(len(request.samples))
def get_state(self, trans, request):
return request.state
def apply_default_filter( self, trans, query, **kwd ):
return query.filter_by( user=trans.user )
def build_initial_query( self, session ):
return session.query( self.model_class )
class Requests( BaseController ):
request_grid = RequestsListGrid()
request_grid = RequestsGrid()
@web.expose
@web.require_login( "create/submit sequencing requests" )
@@ -71,50 +123,43 @@ class Requests( BaseController ):
@web.expose
@web.require_login( "create/submit sequencing requests" )
def list( self, trans, **kwargs ):
def list( self, trans, **kwd ):
'''
List all request made by the current user
'''
status = message = None
self.request_grid.default_filter = dict(state=trans.app.model.Request.states.UNSUBMITTED,
deleted=False)
if 'operation' in kwargs:
operation = kwargs['operation'].lower()
if 'operation' in kwd:
operation = kwd['operation'].lower()
if not kwd.get( 'id', None ):
return trans.response.send_redirect( web.url_for( controller='requests',
action='list',
status='error',
message="Invalid request ID") )
if operation == "show_request":
id = trans.security.decode_id(kwargs['id'])
return self.__show_request(trans, id, kwargs.get('add_sample', False))
return self.__show_request( trans, **kwd )
elif operation == "submit":
id = trans.security.decode_id(kwargs['id'])
return self.__submit_request(trans, id)
return self.__submit_request( trans, **kwd )
elif operation == "delete":
id = trans.security.decode_id(kwargs['id'])
return self.__delete_request(trans, id)
return self.__delete_request( trans, **kwd )
elif operation == "undelete":
id = trans.security.decode_id(kwargs['id'])
return self.__undelete_request(trans, id)
return self.__undelete_request( trans, **kwd )
elif operation == "edit":
id = trans.security.decode_id(kwargs['id'])
return self.__edit_request(trans, id)
if 'show_filter' in kwargs.keys():
if kwargs['show_filter'] == 'All':
self.request_grid.default_filter = {}
elif kwargs['show_filter'] == 'Deleted':
self.request_grid.default_filter = dict(deleted=True)
else:
self.request_grid.default_filter = dict(state=kwargs['show_filter'], deleted=False)
self.request_grid.show_filter = kwargs.get('show_filter', trans.app.model.Request.states.UNSUBMITTED)
return self.__edit_request( trans, **kwd )
# Render the list view
return self.request_grid( trans, **kwargs )
return self.request_grid( trans, **kwd )
def __show_request(self, trans, id, add_sample=False):
def __show_request(self, trans, **kwd):
params = util.Params( kwd )
msg = util.restore_text( params.get( 'msg', '' ) )
messagetype = params.get( 'messagetype', 'done' )
add_sample = params.get('add_sample', False)
try:
request = trans.sa_session.query( trans.app.model.Request ).get( id )
request = trans.sa_session.query( trans.app.model.Request ).get( trans.security.decode_id(kwd['id']) )
except:
return trans.response.send_redirect( web.url_for( controller='requests',
action='list',
status='error',
message="Invalid request ID",
**kwd) )
message="Invalid request ID" ) )
current_samples = []
for s in request.samples:
current_samples.append([s.name, s.values.content])
@@ -122,10 +167,11 @@ class Requests( BaseController ):
current_samples.append(['Sample_%i' % (len(current_samples)+1),['' for field in request.type.sample_form.fields]])
return trans.fill_template( '/requests/show_request.mako',
request=request,
request_details=self.request_details(trans, id),
request_details=self.request_details(trans, request.id),
current_samples = current_samples,
sample_copy=self.__copy_sample(current_samples),
details='hide', edit_mode='False')
details='hide', edit_mode='False',
msg=msg, messagetype=messagetype )
def request_details(self, trans, id):
'''
Shows the request details
@@ -685,7 +731,7 @@ class Requests( BaseController ):
message="Invalid request ID",
**kwd) )
if params.get('show', False) == 'True':
return self.__edit_request(trans, request.id, **kwd)
return self.__edit_request(trans, **kwd)
elif params.get('save_changes_request_button', False) == 'Save changes' \
or params.get('edit_samples_button', False) == 'Edit samples':
request_type = trans.sa_session.query( trans.app.model.RequestType ).get( int( params.select_request_type ) )
@@ -714,11 +760,11 @@ class Requests( BaseController ):
messagetype='done',
**new_kwd) )
elif params.get('refresh', False) == 'true':
return self.__edit_request(trans, request.id, **kwd)
return self.__edit_request(trans, **kwd)
def __edit_request(self, trans, id, **kwd):
def __edit_request(self, trans, **kwd):
try:
request = trans.sa_session.query( trans.app.model.Request ).get( id )
request = trans.sa_session.query( trans.app.model.Request ).get( trans.security.decode_id(kwd['id']) )
except:
msg = "Invalid request ID"
log.warn( msg )
@@ -758,59 +804,61 @@ class Requests( BaseController ):
msg=msg,
messagetype=messagetype)
return self.__show_request_form(trans)
def __delete_request(self, trans, id):
try:
request = trans.sa_session.query( trans.app.model.Request ).get( id )
except:
msg = "Invalid request ID"
log.warn( msg )
return trans.response.send_redirect( web.url_for( controller='requests',
action='list',
status='error',
message=msg,
**kwd) )
# change request's submitted field
if not request.unsubmitted():
return trans.response.send_redirect( web.url_for( controller='requests',
action='list',
status='error',
message='This request cannot be deleted as it is already been submitted',
**kwd) )
request.deleted = True
trans.sa_session.add( request )
trans.sa_session.flush()
kwd = {}
kwd['id'] = trans.security.encode_id(request.id)
def __delete_request(self, trans, **kwd):
id_list = util.listify( kwd['id'] )
delete_failed = []
for id in id_list:
try:
request = trans.sa_session.query( trans.app.model.Request ).get( trans.security.decode_id(id) )
except:
msg = "Invalid request ID"
log.warn( msg )
return trans.response.send_redirect( web.url_for( controller='requests',
action='list',
status='error',
message=msg,
**kwd) )
# a request cannot be deleted once its submitted
if not request.unsubmitted():
delete_failed.append(request.name)
else:
request.deleted = True
trans.sa_session.add( request )
trans.sa_session.flush()
if not len(delete_failed):
msg = '%i request(s) has been deleted.' % len(id_list)
status = 'done'
else:
msg = '%i request(s) has been deleted. %i request %s could not be deleted as they have been submitted.' % (len(id_list)-len(delete_failed),
len(delete_failed), str(delete_failed))
status = 'warning'
return trans.response.send_redirect( web.url_for( controller='requests',
action='list',
status=status,
message=msg) )
def __undelete_request(self, trans, **kwd):
id_list = util.listify( kwd['id'] )
for id in id_list:
try:
request = trans.sa_session.query( trans.app.model.Request ).get( trans.security.decode_id(id) )
except:
msg = "Invalid request ID"
log.warn( msg )
return trans.response.send_redirect( web.url_for( controller='requests',
action='list',
status='error',
message=msg,
**kwd) )
request.deleted = False
trans.sa_session.add( request )
trans.sa_session.flush()
return trans.response.send_redirect( web.url_for( controller='requests',
action='list',
status='done',
message='The request <b>%s</b> has been deleted.' % request.name,
**kwd) )
def __undelete_request(self, trans, id):
message='%i request(s) has been undeleted.' % len(id_list) ) )
def __submit_request(self, trans, **kwd):
try:
request = trans.sa_session.query( trans.app.model.Request ).get( id )
except:
msg = "Invalid request ID"
log.warn( msg )
return trans.response.send_redirect( web.url_for( controller='requests',
action='list',
status='error',
message=msg,
**kwd) )
# change request's submitted field
request.deleted = False
trans.sa_session.add( request )
trans.sa_session.flush()
kwd = {}
kwd['id'] = trans.security.encode_id(request.id)
return trans.response.send_redirect( web.url_for( controller='requests',
action='list',
status='done',
message='The request <b>%s</b> has been undeleted.' % request.name,
**kwd) )
def __submit_request(self, trans, id):
try:
request = trans.sa_session.query( trans.app.model.Request ).get( id )
request = trans.sa_session.query( trans.app.model.Request ).get( trans.security.decode_id(kwd['id']) )
except:
msg = "Invalid request ID"
log.warn( msg )
@@ -837,14 +885,12 @@ class Requests( BaseController ):
request.state = request.states.SUBMITTED
trans.sa_session.add( request )
trans.sa_session.flush()
kwd = {}
kwd['id'] = trans.security.encode_id(request.id)
kwd['status'] = 'done'
kwd['message'] = 'The request <b>%s</b> has been submitted.' % request.name
return trans.response.send_redirect( web.url_for( controller='requests',
action='list',
show_filter=trans.app.model.Request.states.SUBMITTED,
**kwd) )
id=trans.security.encode_id(request.id),
status='done',
message='The request <b>%s</b> has been submitted.' % request.name
) )
@web.expose
@web.require_login( "create/submit sequencing requests" )
def show_events(self, trans, **kwd):
lib/galaxy/web/controllers/requests_admin.py
+419 -242
View File
@@ -15,63 +15,187 @@ log = logging.getLogger( __name__ )
# ---- Request Grid ------------------------------------------------------------
#
class RequestsListGrid( grids.Grid ):
class RequestsGrid( grids.Grid ):
# Custom column types
class NameColumn( grids.TextColumn ):
def get_value(self, trans, grid, request):
return request.name
class DescriptionColumn( grids.TextColumn ):
def get_value(self, trans, grid, request):
return request.desc
class SamplesColumn( grids.GridColumn ):
def get_value(self, trans, grid, request):
return str(len(request.samples))
class TypeColumn( grids.TextColumn ):
def get_value(self, trans, grid, request):
return request.type.name
class LastUpdateColumn( grids.TextColumn ):
def get_value(self, trans, grid, request):
return request.update_time
class StateColumn( grids.GridColumn ):
def filter( self, db_session, query, column_filter ):
""" Modify query to filter request by state. """
if column_filter == "All":
return query
if column_filter:
query = query.filter( model.Request.state == column_filter )
return query
def get_accepted_filters( self ):
""" Returns a list of accepted filters for this column. """
accepted_filter_labels_and_vals = [ model.Request.states.UNSUBMITTED,
model.Request.states.SUBMITTED,
model.Request.states.COMPLETE,
"All"]
accepted_filters = []
for val in accepted_filter_labels_and_vals:
label = val.lower()
args = { self.key: val }
accepted_filters.append( grids.GridColumnFilter( label, args) )
return accepted_filters
class UserColumn( grids.TextColumn ):
def get_value(self, trans, grid, request):
return request.user.email
class DeletedColumn( grids.GridColumn ):
def get_accepted_filters( self ):
""" Returns a list of accepted filters for this column. """
accepted_filter_labels_and_vals = { "active" : "False", "deleted" : "True", "all": "All" }
accepted_filters = []
for label, val in accepted_filter_labels_and_vals.items():
args = { self.key: val }
accepted_filters.append( grids.GridColumnFilter( label, args) )
return accepted_filters
# Grid definition
title = "Sequencing Requests"
template = "admin/requests/grid.mako"
model_class = model.Request
default_sort_key = "-create_time"
show_filter = model.Request.states.SUBMITTED
num_rows_per_page = 50
preserve_state = True
use_paging = True
default_filter = dict( deleted="False", state=model.Request.states.SUBMITTED)
columns = [
grids.GridColumn( "Name", key="name",
link=( lambda item: iff( item.deleted, None, dict( operation="show_request", id=item.id ) ) ),
attach_popup=True ),
grids.GridColumn( "Description", key="desc"),
grids.GridColumn( "Sample(s)", method='number_of_samples',
link=( lambda item: iff( item.deleted, None, dict( operation="show_request", id=item.id ) ) ), ),
grids.GridColumn( "Type", key="request_type_id", method='get_request_type'),
grids.GridColumn( "Last update", key="update_time", format=time_ago ),
grids.GridColumn( "State", key='state'),
grids.GridColumn( "User", key="user_id", method='get_user')
NameColumn( "Name",
key="name",
model_class=model.Request,
link=( lambda item: iff( item.deleted, None, dict( operation="show_request", id=item.id ) ) ),
attach_popup=True,
filterable="advanced" ),
DescriptionColumn( "Description",
key='desc',
model_class=model.Request,
filterable="advanced" ),
SamplesColumn( "Sample(s)",
link=( lambda item: iff( item.deleted, None, dict( operation="show_request", id=item.id ) ) ), ),
TypeColumn( "Type" ),
LastUpdateColumn( "Last update",
format=time_ago ),
StateColumn( "State",
key='state',
filterable="advanced"),
UserColumn( "User",
key='user.email',
model_class=model.Request,
filterable="advanced" ),
DeletedColumn( "Deleted",
key="deleted",
visible=True,
filterable="advanced" )
]
columns.append( grids.MulticolFilterColumn( "Search",
cols_to_filter=[ columns[0], columns[1], columns[6] ],
key="free-text-search",
visible=False,
filterable="standard" ) )
operations = [
grids.GridOperation( "Submit", allow_multiple=False, condition=( lambda item: not item.deleted and item.unsubmitted() and item.samples ) ),
grids.GridOperation( "Edit", allow_multiple=False, condition=( lambda item: not item.deleted ) ),
grids.GridOperation( "Reject", allow_multiple=False, condition=( lambda item: not item.deleted and item.submitted() ) ),
grids.GridOperation( "Delete", allow_multiple=False, condition=( lambda item: not item.deleted and item.unsubmitted() ) ),
grids.GridOperation( "Delete", allow_multiple=True, condition=( lambda item: not item.deleted and item.unsubmitted() ) ),
grids.GridOperation( "Undelete", condition=( lambda item: item.deleted ) ),
]
standard_filters = [
grids.GridColumnFilter( model.Request.states.UNSUBMITTED,
args=dict( state=model.Request.states.UNSUBMITTED, deleted=False ) ),
grids.GridColumnFilter( model.Request.states.SUBMITTED,
args=dict( state=model.Request.states.SUBMITTED, deleted=False ) ),
grids.GridColumnFilter( model.Request.states.COMPLETE, args=dict( state=model.Request.states.COMPLETE, deleted=False ) ),
grids.GridColumnFilter( "Deleted", args=dict( deleted=True ) ),
grids.GridColumnFilter( "All", args=dict( deleted=False ) )
global_actions = [
grids.GridAction( "Create new request", dict( controller='requests_admin',
action='new',
select_request_type='True' ) )
]
def get_user(self, trans, request):
return trans.sa_session.query( trans.app.model.User ).get( request.user_id ).email
def get_current_item( self, trans ):
return None
def get_request_type(self, trans, request):
request_type = trans.sa_session.query( trans.app.model.RequestType ).get( request.request_type_id )
return request_type.name
def number_of_samples(self, trans, request):
return str(len(request.samples))
def apply_default_filter( self, trans, query, **kwargs ):
if self.default_filter:
return query.filter_by( **self.default_filter )
else:
return query
#
# ---- Request Type Gridr ------------------------------------------------------
#
class RequestTypeGrid( grids.Grid ):
# Custom column types
class NameColumn( grids.TextColumn ):
def get_value(self, trans, grid, request_type):
return request_type.name
class DescriptionColumn( grids.TextColumn ):
def get_value(self, trans, grid, request_type):
return request_type.desc
class RequestFormColumn( grids.TextColumn ):
def get_value(self, trans, grid, request_type):
return request_type.request_form.name
class SampleFormColumn( grids.TextColumn ):
def get_value(self, trans, grid, request_type):
return request_type.sample_form.name
class DeletedColumn( grids.GridColumn ):
def get_accepted_filters( self ):
""" Returns a list of accepted filters for this column. """
accepted_filter_labels_and_vals = { "active" : "False", "deleted" : "True", "all": "All" }
accepted_filters = []
for label, val in accepted_filter_labels_and_vals.items():
args = { self.key: val }
accepted_filters.append( grids.GridColumnFilter( label, args) )
return accepted_filters
# Grid definition
title = "Requests Types"
template = "admin/requests/manage_request_types.mako"
model_class = model.RequestType
default_sort_key = "-create_time"
num_rows_per_page = 50
preserve_state = True
use_paging = True
default_filter = dict( deleted="False" )
columns = [
NameColumn( "Name",
key="name",
model_class=model.RequestType,
link=( lambda item: iff( item.deleted, None, dict( operation="view", id=item.id ) ) ),
attach_popup=True,
filterable="advanced" ),
DescriptionColumn( "Description",
key='desc',
model_class=model.Request,
filterable="advanced" ),
RequestFormColumn( "Request Form",
link=( lambda item: iff( item.deleted, None, dict( operation="view_form", id=item.request_form.id ) ) ), ),
SampleFormColumn( "Sample Form",
link=( lambda item: iff( item.deleted, None, dict( operation="view_form", id=item.sample_form.id ) ) ), ),
DeletedColumn( "Deleted",
key="deleted",
visible=False,
filterable="advanced" )
]
columns.append( grids.MulticolFilterColumn( "Search",
cols_to_filter=[ columns[0], columns[1] ],
key="free-text-search",
visible=False,
filterable="standard" ) )
operations = [
#grids.GridOperation( "Update", allow_multiple=False, condition=( lambda item: not item.deleted ) ),
grids.GridOperation( "Delete", allow_multiple=True, condition=( lambda item: not item.deleted ) ),
grids.GridOperation( "Undelete", condition=( lambda item: item.deleted ) ),
]
global_actions = [
grids.GridAction( "Create new request type", dict( controller='requests_admin',
action='create_request_type' ) )
]
#
# ---- Request Controller ------------------------------------------------------
#
class Requests( BaseController ):
request_grid = RequestsListGrid()
request_grid = RequestsGrid()
requesttype_grid = RequestTypeGrid()
@web.expose
@web.require_admin
@@ -80,67 +204,59 @@ class Requests( BaseController ):
@web.expose
@web.require_admin
def list( self, trans, **kwargs ):
def list( self, trans, **kwd ):
'''
List all request made by the current user
'''
message = util.restore_text( kwargs.get( 'message', '' ) )
status = kwargs.get( 'status', 'done' )
self.request_grid.default_filter = dict(state=trans.app.model.Request.states.SUBMITTED,
deleted=False)
if 'operation' in kwargs:
operation = kwargs['operation'].lower()
if 'operation' in kwd:
operation = kwd['operation'].lower()
if not kwd.get( 'id', None ):
return trans.response.send_redirect( web.url_for( controller='requests_admin',
action='list',
status='error',
message="Invalid request ID") )
if operation == "show_request":
id = trans.security.decode_id(kwargs['id'])
return self.__show_request(trans, id, status, message)
return self.__show_request( trans, **kwd )
elif operation == "submit":
id = trans.security.decode_id(kwargs['id'])
return self.__submit_request(trans, id)
elif operation == "edit":
id = trans.security.decode_id(kwargs['id'])
return self.__edit_request(trans, id)
return self.__submit_request( trans, **kwd )
elif operation == "delete":
id = trans.security.decode_id(kwargs['id'])
return self.__delete_request(trans, id)
return self.__delete_request( trans, **kwd )
elif operation == "undelete":
id = trans.security.decode_id(kwargs['id'])
return self.__undelete_request(trans, id)
return self.__undelete_request( trans, **kwd )
elif operation == "edit":
return self.__edit_request( trans, **kwd )
elif operation == "reject":
id = trans.security.decode_id(kwargs['id'])
return self.__reject_request(trans, id)
if 'show_filter' in kwargs.keys():
if kwargs['show_filter'] == 'All':
self.request_grid.default_filter = {}
elif kwargs['show_filter'] == 'Deleted':
self.request_grid.default_filter = dict(deleted=True)
else:
self.request_grid.default_filter = dict(state=kwargs['show_filter'], deleted=False)
self.request_grid.show_filter = kwargs.get('show_filter', trans.app.model.Request.states.SUBMITTED)
# Render the list view
return self.request_grid( trans, **kwargs )
def __show_request(self, trans, id, messagetype, msg):
return self.__reject_request( trans, **kwd )
# Render the grid view
return self.request_grid( trans, **kwd )
def __show_request(self, trans, **kwd):
params = util.Params( kwd )
msg = util.restore_text( params.get( 'msg', '' ) )
messagetype = params.get( 'messagetype', 'done' )
add_sample = params.get('add_sample', False)
try:
request = trans.sa_session.query( trans.app.model.Request ).get( id )
request = trans.sa_session.query( trans.app.model.Request ).get( trans.security.decode_id(kwd['id']) )
except:
return trans.response.send_redirect( web.url_for( controller='requests_admin',
action='list',
status='error',
message="Invalid request ID",
**kwd) )
message="Invalid request ID") )
current_samples = []
for s in request.samples:
current_samples.append([s.name, s.values.content])
if add_sample:
current_samples.append(['Sample_%i' % (len(current_samples)+1),['' for field in request.type.sample_form.fields]])
return trans.fill_template( '/admin/requests/show_request.mako',
request=request,
request_details=self.request_details(trans, id),
request_details=self.request_details(trans, request.id),
current_samples = current_samples,
sample_copy=self.__copy_sample(current_samples),
details='hide', edit_mode='False',
msg=msg, messagetype=messagetype)
msg=msg, messagetype=messagetype )
def __edit_request(self, trans, id, **kwd):
def __edit_request(self, trans, **kwd):
try:
request = trans.sa_session.query( trans.app.model.Request ).get( id )
request = trans.sa_session.query( trans.app.model.Request ).get( trans.security.decode_id(kwd['id']) )
except:
msg = "Invalid request ID"
log.warn( msg )
@@ -180,61 +296,61 @@ class Requests( BaseController ):
msg=msg,
messagetype=messagetype)
return self.__show_request_form(trans)
def __delete_request(self, trans, id):
try:
request = trans.sa_session.query( trans.app.model.Request ).get( id )
except:
msg = "Invalid request ID"
log.warn( msg )
return trans.response.send_redirect( web.url_for( controller='requests_admin',
action='list',
status='error',
message=msg,
**kwd) )
# change request's submitted field
if not request.unsubmitted():
return trans.response.send_redirect( web.url_for( controller='requests_admin',
action='list',
status='error',
message='This request cannot be deleted as it is already been submitted',
**kwd) )
request.deleted = True
trans.sa_session.add( request )
trans.sa_session.flush()
kwd = {}
kwd['id'] = trans.security.encode_id(request.id)
def __delete_request(self, trans, **kwd):
id_list = util.listify( kwd['id'] )
delete_failed = []
for id in id_list:
try:
request = trans.sa_session.query( trans.app.model.Request ).get( trans.security.decode_id(id) )
except:
msg = "Invalid request ID"
log.warn( msg )
return trans.response.send_redirect( web.url_for( controller='requests_admin',
action='list',
status='error',
message=msg,
**kwd) )
# a request cannot be deleted once its submitted
if not request.unsubmitted():
delete_failed.append(request.name)
else:
request.deleted = True
trans.sa_session.add( request )
trans.sa_session.flush()
if not len(delete_failed):
msg = '%i request(s) has been deleted.' % len(id_list)
status = 'done'
else:
msg = '%i request(s) has been deleted. %i request %s could not be deleted as they have been submitted.' % (len(id_list)-len(delete_failed),
len(delete_failed), str(delete_failed))
status = 'warning'
return trans.response.send_redirect( web.url_for( controller='requests_admin',
action='list',
show_filter=trans.app.model.Request.states.UNSUBMITTED,
status='done',
message='The request <b>%s</b> has been deleted.' % request.name,
**kwd) )
def __undelete_request(self, trans, id):
try:
request = trans.sa_session.query( trans.app.model.Request ).get( id )
except:
msg = "Invalid request ID"
log.warn( msg )
return trans.response.send_redirect( web.url_for( controller='requests_admin',
action='list',
status='error',
message=msg,
**kwd) )
# change request's submitted field
request.deleted = False
trans.sa_session.add( request )
trans.sa_session.flush()
kwd = {}
kwd['id'] = trans.security.encode_id(request.id)
status=status,
message=msg) )
def __undelete_request(self, trans, **kwd):
id_list = util.listify( kwd['id'] )
for id in id_list:
try:
request = trans.sa_session.query( trans.app.model.Request ).get( trans.security.decode_id(id) )
except:
msg = "Invalid request ID"
log.warn( msg )
return trans.response.send_redirect( web.url_for( controller='requests_admin',
action='list',
status='error',
message=msg,
**kwd) )
request.deleted = False
trans.sa_session.add( request )
trans.sa_session.flush()
return trans.response.send_redirect( web.url_for( controller='requests_admin',
action='list',
show_filter=trans.app.model.Request.states.UNSUBMITTED,
status='done',
message='The request <b>%s</b> has been undeleted.' % request.name,
**kwd) )
def __submit_request(self, trans, id):
message='%i request(s) has been undeleted.' % len(id_list) ) )
def __submit_request(self, trans, **kwd):
try:
request = trans.sa_session.query( trans.app.model.Request ).get( id )
request = trans.sa_session.query( trans.app.model.Request ).get( trans.security.decode_id(kwd['id']) )
except:
msg = "Invalid request ID"
log.warn( msg )
@@ -260,15 +376,32 @@ class Requests( BaseController ):
request.state = request.states.SUBMITTED
trans.sa_session.add( request )
trans.sa_session.flush()
kwd = {}
kwd['id'] = trans.security.encode_id(request.id)
kwd['status'] = 'done'
kwd['message'] = 'The request <b>%s</b> has been submitted.' % request.name
return trans.response.send_redirect( web.url_for( controller='requests_admin',
action='list',
show_filter=trans.app.model.Request.states.SUBMITTED,
**kwd) )
id=trans.security.encode_id(request.id),
status='done',
message='The request <b>%s</b> has been submitted.' % request.name
) )
def __reject_request(self, trans, **kwd):
try:
request = trans.sa_session.query( trans.app.model.Request ).get( trans.security.decode_id(kwd['id']) )
except:
msg = "Invalid request ID"
log.warn( msg )
return trans.response.send_redirect( web.url_for( controller='requests_admin',
action='list',
status='error',
message=msg,
**kwd) )
# change request's submitted field
request.state = request.states.UNSUBMITTED
trans.sa_session.add( request )
trans.sa_session.flush()
return trans.response.send_redirect( web.url_for( controller='requests_admin',
action='list',
status='done',
message='The request <b>%s</b> is now unsubmitted.' % request.name
) )
#
#---- Request Creation ----------------------------------------------------------
#
@@ -325,7 +458,6 @@ class Requests( BaseController ):
if params.get('create_request_button', False) == 'Save':
return trans.response.send_redirect( web.url_for( controller='requests_admin',
action='list',
show_filter=trans.app.model.Request.states.UNSUBMITTED,
message=msg ,
status='done') )
elif params.get('create_request_samples_button', False) == 'Add samples':
@@ -664,29 +796,6 @@ class Requests( BaseController ):
**new_kwd) )
elif params.get('refresh', False) == 'true':
return self.__edit_request(trans, request.id, **kwd)
def __reject_request(self, trans, id):
try:
request = trans.sa_session.query( trans.app.model.Request ).get( id )
except:
msg = "Invalid request ID"
log.warn( msg )
return trans.response.send_redirect( web.url_for( controller='requests_admin',
action='list',
status='error',
message=msg,
**kwd) )
# change request's submitted field
request.state = request.states.UNSUBMITTED
trans.sa_session.add( request )
trans.sa_session.flush()
kwd = {}
kwd['id'] = trans.security.encode_id(request.id)
kwd['status'] = 'done'
kwd['message'] = 'The request <b>%s</b> is now unsubmitted.' % request.name
return trans.response.send_redirect( web.url_for( controller='requests_admin',
action='list',
show_filter=trans.app.model.Request.states.UNSUBMITTED,
**kwd) )
def __update_samples(self, request, **kwd):
'''
This method retrieves all the user entered sample information and
@@ -1049,8 +1158,8 @@ class Requests( BaseController ):
action='list',
operation='show_request',
id=trans.security.encode_id(request.id),
message='Bar codes have been saved for this request',
status='done'))
msg='Bar codes have been saved for this request',
messagetype='done'))
def __set_request_state( self, trans, request ):
# check if all the samples of the current request are in the final state
complete = True
@@ -1138,50 +1247,72 @@ class Requests( BaseController ):
##
@web.expose
@web.require_admin
def manage_request_types( self, trans, **kwd ):
params = util.Params( kwd )
msg = util.restore_text( params.get( 'msg', '' ) )
messagetype = params.get( 'messagetype', 'done' )
show_filter = util.restore_text( params.get( 'show_filter', 'Active' ) )
forms = get_all_forms(trans, all_versions=True)
request_types_list = trans.sa_session.query( trans.app.model.RequestType )
if show_filter == 'All':
request_types = request_types_list
elif show_filter == 'Deleted':
request_types = [rt for rt in request_types_list if rt.deleted]
else:
request_types = [rt for rt in request_types_list if not rt.deleted]
return trans.fill_template( '/admin/requests/manage_request_types.mako',
request_types=request_types,
forms=forms,
show_filter=show_filter,
msg=msg,
messagetype=messagetype )
def manage_request_types( self, trans, **kwd ):
if 'operation' in kwd:
operation = kwd['operation'].lower()
if not kwd.get( 'id', None ):
return trans.response.send_redirect( web.url_for( controller='requests_admin',
action='manage_request_types',
status='error',
message="Invalid requesttype ID") )
if operation == "view":
return self.__view_request_type( trans, **kwd )
elif operation == "view_form":
return self.__view_form( trans, **kwd )
elif operation == "delete":
return self.__delete_request_type( trans, **kwd )
elif operation == "undelete":
return self.__undelete_request_type( trans, **kwd )
# elif operation == "update":
# return self.__edit_request( trans, **kwd )
# Render the grid view
return self.requesttype_grid( trans, **kwd )
def __view_request_type(self, trans, **kwd):
try:
rt = trans.sa_session.query( trans.app.model.RequestType ).get( trans.security.decode_id(kwd['id']) )
except:
return trans.response.send_redirect( web.url_for( controller='requests_admin',
action='manage_request_types',
status='error',
message="Invalid requesttype ID") )
return trans.fill_template( '/admin/requests/view_request_type.mako',
request_type=rt,
forms=get_all_forms( trans ),
states_list=rt.states )
def __view_form(self, trans, **kwd):
try:
fd = trans.sa_session.query( trans.app.model.FormDefinition ).get( trans.security.decode_id(kwd['id']) )
except:
return trans.response.send_redirect( web.url_for( controller='requests_admin',
action='manage_request_types',
status='error',
message="Invalid form ID") )
return trans.fill_template( '/admin/forms/show_form_read_only.mako',
form=fd )
@web.expose
@web.require_admin
def request_type( self, trans, **kwd ):
def create_request_type( self, trans, **kwd ):
params = util.Params( kwd )
msg = util.restore_text( params.get( 'msg', '' ) )
messagetype = params.get( 'messagetype', 'done' )
if params.get( 'create', False ):
if params.get( 'add_state_button', False ):
rt_info, rt_states = self.__create_request_type_form(trans, **kwd)
rt_states.append(("", ""))
return trans.fill_template( '/admin/requests/create_request_type.mako',
request_forms=get_all_forms( trans,
filter=dict(deleted=False),
form_type=trans.app.model.FormDefinition.types.REQUEST ),
sample_forms=get_all_forms( trans,
filter=dict(deleted=False),
form_type=trans.app.model.FormDefinition.types.SAMPLE ),
rt_info_widgets=rt_info,
rt_states_widgets=rt_states,
msg=msg,
messagetype=messagetype)
elif params.get( 'define_states_button', False ):
return trans.fill_template( '/admin/requests/add_states.mako',
request_type_name=util.restore_text( params.name ),
desc=util.restore_text( params.description ),
num_states=int(util.restore_text( params.num_states )),
request_form_id=int(util.restore_text( params.request_form_id )),
sample_form_id=int(util.restore_text( params.sample_form_id )),
elif params.get( 'remove_state_button', False ):
rt_info, rt_states = self.__create_request_type_form(trans, **kwd)
index = int(params.get( 'remove_state_button', '' ).split(" ")[2])
del rt_states[index-1]
return trans.fill_template( '/admin/requests/create_request_type.mako',
rt_info_widgets=rt_info,
rt_states_widgets=rt_states,
msg=msg,
messagetype=messagetype)
messagetype=messagetype)
elif params.get( 'save_request_type', False ):
st, msg = self.__save_request_type(trans, **kwd)
if not st:
@@ -1191,32 +1322,65 @@ class Requests( BaseController ):
messagetype='error')
return trans.response.send_redirect( web.url_for( controller='requests_admin',
action='manage_request_types',
msg='Request type <b>%s</b> has been created' % st.name,
messagetype='done') )
elif params.get('view', False):
rt = trans.sa_session.query( trans.app.model.RequestType ).get( int( util.restore_text( params.id ) ) )
return trans.fill_template( '/admin/requests/view_request_type.mako',
request_type=rt,
forms=get_all_forms( trans ),
states_list=rt.states,
deleted=False,
show_deleted=False,
message='Request type <b>%s</b> has been created' % st.name,
status='done') )
else:
rt_info, rt_states = self.__create_request_type_form(trans, **kwd)
return trans.fill_template( '/admin/requests/create_request_type.mako',
rt_info_widgets=rt_info,
rt_states_widgets=rt_states,
msg=msg,
messagetype=messagetype )
messagetype=messagetype)
def __create_request_type_form(self, trans, **kwd):
request_forms=get_all_forms( trans,
filter=dict(deleted=False),
form_type=trans.app.model.FormDefinition.types.REQUEST )
sample_forms=get_all_forms( trans,
filter=dict(deleted=False),
form_type=trans.app.model.FormDefinition.types.SAMPLE )
if not len(request_forms) or not len(sample_forms):
return [],[]
params = util.Params( kwd )
rt_info = []
rt_info.append(dict(label='Name',
widget=TextField('name', 40, util.restore_text( params.get( 'name', '' ) ) ) ))
rt_info.append(dict(label='Description',
widget=TextField('desc', 40, util.restore_text( params.get( 'desc', '' ) ) ) ))
rf_selectbox = SelectField('request_form_id')
for fd in request_forms:
if str(fd.id) == params.get( 'request_form_id', '' ):
rf_selectbox.add_option(fd.name, fd.id, selected=True)
else:
rf_selectbox.add_option(fd.name, fd.id)
rt_info.append(dict(label='Request form',
widget=rf_selectbox ))
sf_selectbox = SelectField('sample_form_id')
for fd in sample_forms:
if str(fd.id) == params.get( 'sample_form_id', '' ):
sf_selectbox.add_option(fd.name, fd.id, selected=True)
else:
sf_selectbox.add_option(fd.name, fd.id)
rt_info.append(dict(label='Sample form',
widget=sf_selectbox ))
# possible sample states
rt_states = []
i=0
while True:
if kwd.has_key( 'state_name_%i' % i ):
rt_states.append((params.get( 'state_name_%i' % i, '' ),
params.get( 'state_desc_%i' % i, '' )))
i=i+1
else:
break
return rt_info, rt_states
def __save_request_type(self, trans, **kwd):
params = util.Params( kwd )
num_states = int( util.restore_text( params.get( 'num_states', 0 ) ))
proceed = True
for i in range( num_states ):
if not util.restore_text( params.get( 'state_name_%i' % i, None ) ):
proceed = False
break
if not proceed:
msg = "All the state name(s) must be completed."
return None, msg
rt = trans.app.model.RequestType()
rt.name = util.restore_text( params.name )
rt.desc = util.restore_text( params.description ) or ""
rt.name = util.restore_text( params.get( 'name', '' ) )
rt.desc = util.restore_text( params.get( 'desc', '' ) )
rt.request_form = trans.sa_session.query( trans.app.model.FormDefinition ).get( int( params.request_form_id ) )
rt.sample_form = trans.sa_session.query( trans.app.model.FormDefinition ).get( int( params.sample_form_id ) )
trans.sa_session.add( rt )
@@ -1226,37 +1390,50 @@ class Requests( BaseController ):
for ss in ss_list:
trans.sa_session.delete( ss )
trans.sa_session.flush()
for i in range( num_states ):
name = util.restore_text( params.get( 'state_name_%i' % i, None ))
desc = util.restore_text( params.get( 'state_desc_%i' % i, None ))
ss = trans.app.model.SampleState(name, desc, rt)
trans.sa_session.add( ss )
trans.sa_session.flush()
msg = "The new request type named '%s' with %s state(s) has been created" % (rt.name, num_states)
i=0
while True:
if kwd.has_key( 'state_name_%i' % i ):
name = util.restore_text( params.get( 'state_name_%i' % i, None ))
desc = util.restore_text( params.get( 'state_desc_%i' % i, None ))
ss = trans.app.model.SampleState(name, desc, rt)
trans.sa_session.add( ss )
trans.sa_session.flush()
i = i + 1
else:
break
msg = "The new request type named '%s' with %s state(s) has been created" % (rt.name, i)
return rt, msg
@web.expose
@web.require_admin
def delete_request_type( self, trans, **kwd ):
params = util.Params( kwd )
msg = util.restore_text( params.get( 'msg', '' ) )
messagetype = params.get( 'messagetype', 'done' )
rt = trans.sa_session.query( trans.app.model.RequestType ).get( int( util.restore_text( params.request_type_id ) ) )
rt.deleted = True
trans.sa_session.flush()
def __delete_request_type( self, trans, **kwd ):
id_list = util.listify( kwd['id'] )
for id in id_list:
try:
rt = trans.sa_session.query( trans.app.model.RequestType ).get( trans.security.decode_id(id) )
except:
return trans.response.send_redirect( web.url_for( controller='requests_admin',
action='manage_request_types',
msg='Invalid request type ID',
messagetype='error') )
rt.deleted = True
trans.sa_session.add( rt )
trans.sa_session.flush()
return trans.response.send_redirect( web.url_for( controller='requests_admin',
action='manage_request_types',
msg='Request type <b>%s</b> has been deleted' % rt.name,
msg='%i request type(s) has been deleted' % len(id_list),
messagetype='done') )
@web.expose
@web.require_admin
def undelete_request_type( self, trans, **kwd ):
params = util.Params( kwd )
msg = util.restore_text( params.get( 'msg', '' ) )
messagetype = params.get( 'messagetype', 'done' )
rt = trans.sa_session.query( trans.app.model.RequestType ).get( int( util.restore_text( params.request_type_id ) ) )
rt.deleted = False
trans.sa_session.flush()
def __undelete_request_type( self, trans, **kwd ):
id_list = util.listify( kwd['id'] )
for id in id_list:
try:
rt = trans.sa_session.query( trans.app.model.RequestType ).get( trans.security.decode_id(id) )
except:
return trans.response.send_redirect( web.url_for( controller='requests_admin',
action='manage_request_types',
msg='Invalid request type ID',
messagetype='error') )
rt.deleted = False
trans.sa_session.add( rt )
trans.sa_session.flush()
return trans.response.send_redirect( web.url_for( controller='requests_admin',
action='manage_request_types',
msg='Request type <b>%s</b> has been undeleted' % rt.name,
msg='%i request type(s) has been undeleted' % len(id_list),
messagetype='done') )
lib/galaxy/web/controllers/user.py
-2
View File
@@ -181,9 +181,7 @@ class User( BaseController ):
refresh_frames = [ 'masthead', 'history' ]
if not trans.app.config.allow_user_creation and not trans.user_is_admin():
return trans.show_error_message( 'User registration is disabled. Please contact your Galaxy administrator for an account.' )
#
# Create the user, save all the user info and login to Galaxy
#
if params.get('create_user_button', None) == "Submit":
# check email and password validity
error = self.__validate(trans, params, email, password, confirm)
lib/galaxy/web/framework/__init__.py
+1 -9
View File
@@ -446,13 +446,11 @@ class UniverseWebTransaction( base.DefaultWebTransaction ):
self.sa_session.flush()
# This method is not called from the Galaxy reports, so the cookie will always be galaxysession
self.__update_session_cookie( name='galaxysession' )
def get_galaxy_session( self ):
"""
Return the current galaxy session
"""
return self.galaxy_session
def get_history( self, create=False ):
"""
Load the current history, creating a new one only if there is not
@@ -497,7 +495,6 @@ class UniverseWebTransaction( base.DefaultWebTransaction ):
self.sa_session.add_all( ( self.galaxy_session, history ) )
self.sa_session.flush()
return history
def get_user( self ):
"""Return the current user if logged in or None."""
return self.galaxy_session.user
@@ -507,7 +504,6 @@ class UniverseWebTransaction( base.DefaultWebTransaction ):
self.sa_session.add( self.galaxy_session )
self.sa_session.flush()
user = property( get_user, set_user )
def get_user_and_roles( self ):
user = self.get_user()
if user:
@@ -515,13 +511,9 @@ class UniverseWebTransaction( base.DefaultWebTransaction ):
else:
roles = []
return user, roles
def user_is_admin( self ):
admin_users = self.app.config.get( "admin_users", "" ).split( "," )
if self.user and admin_users and self.user.email in admin_users:
return True
return False
return self.user and admin_users and self.user.email in admin_users
def get_toolbox(self):
"""Returns the application toolbox"""
return self.app.toolbox
lib/galaxy/web/framework/helpers/grids.py
+6 -2
View File
@@ -1,6 +1,7 @@
from galaxy.model import *
from galaxy.model.orm import *
from galaxy.web.framework.helpers import iff
from galaxy.tags.tag_handler import TagHandler
from galaxy.web import url_for
from galaxy.util.json import from_json_string, to_json_string
@@ -16,7 +17,9 @@ class Grid( object ):
title = ""
exposed = True
model_class = None
# To use grid's async features, set template="grid_base_async.mako"
template = "grid_base.mako"
async_template = "grid_body_async.mako"
global_actions = []
columns = []
operations = []
@@ -213,7 +216,7 @@ class Grid( object ):
return url_for( **new_kwargs )
return trans.fill_template( self.template,
return trans.fill_template( iff( 'async' not in kwargs, self.template, self.async_template),
grid=self,
query=query,
cur_page_num = page_num,
@@ -390,7 +393,7 @@ class MulticolFilterColumn( TextColumn ):
return query.filter( complete_filter )
class GridOperation( object ):
def __init__( self, label, key=None, condition=None, allow_multiple=True, allow_popup=True, target=None, url_args=None ):
def __init__( self, label, key=None, condition=None, allow_multiple=True, allow_popup=True, target=None, url_args=None, async_compatible=False ):
self.label = label
self.key = key
self.allow_multiple = allow_multiple
@@ -398,6 +401,7 @@ class GridOperation( object ):
self.condition = condition
self.target = target
self.url_args = url_args
self.async_compatible = async_compatible
def get_url_args( self, item ):
if self.url_args:
temp = dict( self.url_args )
run.sh
+19
View File
@@ -1,4 +1,23 @@
#!/bin/sh
cd `dirname $0`
# explicitly attempt to fetch eggs before running
FETCH_EGGS=1
for arg in "$@"; do
[ "$arg" = "--stop-daemon" ] && FETCH_EGGS=0; break
done
if [ $FETCH_EGGS -eq 1 ]; then
python -ES ./scripts/check_eggs.py quiet
if [ $? -ne 0 ]; then
echo "Some eggs are out of date, attempting to fetch..."
python -ES ./scripts/fetch_eggs.py
if [ $? -eq 0 ]; then
echo "Fetch successful."
else
echo "Fetch failed."
exit 1
fi
fi
fi
python -ES ./scripts/paster.py serve universe_wsgi.ini $@
scripts/check_eggs.py
+11 -3
View File
@@ -11,6 +11,12 @@ root.addHandler( logging.StreamHandler( sys.stdout ) )
lib = os.path.abspath( os.path.join( os.path.dirname( __file__ ), "..", "lib" ) )
sys.path.append( lib )
try:
assert sys.argv[1] == 'quiet'
quiet = True
except:
quiet = False
from galaxy.eggs import *
c = Crate()
@@ -21,7 +27,9 @@ for name in c.get_names():
if not galaxy_config.check_conditional( name ):
ignore.append( name )
if not c.find( ignore=ignore ):
print "Some of your Galaxy eggs are out of date. Please update them"
print "by running:"
print " python scripts/fetch_eggs.py"
if not quiet:
print "Some of your Galaxy eggs are out of date. Please update them"
print "by running:"
print " python scripts/fetch_eggs.py"
sys.exit( 1 )
sys.exit( 0 )
scripts/check_python.py
+8 -11
View File
@@ -1,19 +1,16 @@
import os, sys
msg = """ERROR: Your Python version is: %s
Galaxy is currently supported on Python 2.4, 2.5 and 2.6. To run Galaxy,
please download and install a supported version from python.org. If a
supported version is installed but is not your default, getgalaxy.org
contains instructions on how to force Galaxy to use a different version.""" % sys.version[:3]
def check_python():
return
try:
assert sys.version_info[:2] >= ( 2, 4 ) and sys.version_info[:2] <= ( 2, 5 )
assert sys.version_info[:2] >= ( 2, 4 ) and sys.version_info[:2] <= ( 2, 6 )
except AssertionError:
print >>sys.stderr, "ERROR: Your Python version is:", sys.version.split( ' ', 1 )[0]
print >>sys.stderr, "Galaxy is currently only supported on Python 2.4 and Python 2.5."
if sys.version_info[:2] < ( 2, 4 ):
print >>sys.stderr, "To run Galaxy, please download and install Python 2.5 from http://python.org"
else:
print >>sys.stderr, "To track the progress of Python 2.6 support, please see:"
print >>sys.stderr, " http://bitbucket.org/galaxy/galaxy-central/issue/76/support-python-26"
print >>sys.stderr, "For hints on how to direct Galaxy to use a different python installation, see:"
print >>sys.stderr, " http://bitbucket.org/galaxy/galaxy-central/wiki/GetGalaxy"
print >>sys.stderr, msg
raise
if __name__ == '__main__':
scripts/cleanup_datasets/cleanup_datasets.py
+2 -2
View File
@@ -276,7 +276,7 @@ def purge_datasets( app, cutoff_time, remove_from_disk, info_only = False, force
app.model.Dataset.table.c.update_time < cutoff_time ) )
for dataset in datasets:
file_size = dataset.file_size
_purge_dataset( dataset, remove_from_disk, info_only = info_only )
_purge_dataset( app, dataset, remove_from_disk, info_only = info_only )
dataset_count += 1
try:
disk_space += file_size
@@ -349,7 +349,7 @@ def _delete_dataset( dataset, app, remove_from_disk, info_only=False, is_deletab
app.sa_session.add( dataset )
app.sa_session.flush()
def _purge_dataset( dataset, remove_from_disk, info_only = False ):
def _purge_dataset( app, dataset, remove_from_disk, info_only = False ):
if dataset.deleted:
try:
if dataset.purgable and _dataset_is_deletable( dataset ):
scripts/scramble/scripts/pysqlite.py
+2 -42
View File
@@ -1,18 +1,4 @@
import os, sys, subprocess, tarfile, zipfile, shutil
def unpack_sqlite_source():
print "unpack_sqlite_source(): Found a previously downloaded sqlite source."
print "unpack_sqlite_source(): To force a new download, remove the archive:"
print " ", SQLITE_ARCHIVE
os.makedirs( "sqlite" )
z = zipfile.ZipFile( SQLITE_ARCHIVE, "r" )
for fn in z.namelist():
if fn == "tclsqlite.c" or fn == "shell.c" or fn == "icu.c":
continue
o = open( os.path.join( "sqlite", fn ), "wb" )
o.write( z.read( fn ) )
o.close()
z.close()
import os, sys, shutil
# change back to the build dir
if os.path.dirname( sys.argv[0] ) != "":
@@ -38,42 +24,16 @@ if os.access( ".galaxy_tag", os.F_OK ):
else:
tag = None
SQLITE_VERSION = ( tag.split( "_" ) )[1]
SQLITE_ARCHIVE = os.path.abspath( os.path.join( "..", "..", "..", "archives", "sqlite-source-%s.zip" %SQLITE_VERSION.replace( ".", "_" ) ) )
# clean, in case you're running this by hand from a dirty module source dir
for dir in [ "build", "dist", "sqlite" ]:
if os.access( dir, os.F_OK ):
print "scramble_it.py: removing dir:", dir
shutil.rmtree( dir )
# build/unpack SQLite
unpack_sqlite_source()
# changes to setup.py
file = "setup.py"
print "build(): Patching", file
if not os.access( "%s.orig" %file, os.F_OK ):
shutil.copyfile( file, "%s.orig" %file )
i = open( "%s.orig" %file, "r" )
o = open( file, "w" )
for line in i.readlines():
if line == ' "src/util.c", "src/row.c"]\n':
line += 'sources += glob.glob("./sqlite/*.c")\n'
if line == "include_dirs = []\n":
line = "include_dirs = [ './sqlite' ]\n"
if line == "define_macros = []\n":
line = "define_macros = [ ('THREADSAFE','1') ]\n"
print >>o, line,
i.close()
o.close()
# don't want setup.cfg
os.rename( "setup.cfg", "setup.cfg.orig" )
# tag
me = sys.argv[0]
sys.argv = [ me ]
sys.argv.append( "build_static" )
if tag is not None:
sys.argv.append( "egg_info" )
sys.argv.append( "--tag-build=%s" %tag )
scripts/set_metadata.py
+14 -1
View File
@@ -25,6 +25,7 @@ import galaxy.model.mapping #need to load this before we unpickle, in order to s
galaxy.model.Job() #this looks REAL stupid, but it is REQUIRED in order for SA to insert parameters into the classes defined by the mappers --> it appears that instantiating ANY mapper'ed class would suffice here
galaxy.datatypes.metadata.DATABASE_CONNECTION_AVAILABLE = False #Let metadata know that there is no database connection, and to just assume object ids are valid
from galaxy.util import stringify_dictionary_keys
from galaxy.util.json import from_json_string
from sqlalchemy.orm import clear_mappers
def __main__():
@@ -37,13 +38,25 @@ def __main__():
config_root = sys.argv.pop( 1 )
datatypes_config = sys.argv.pop( 1 )
galaxy.model.set_datatypes_registry( galaxy.datatypes.registry.Registry( config_root, datatypes_config ) )
job_metadata = sys.argv.pop( 1 )
ext_override = dict()
if job_metadata != "None" and os.path.exists( job_metadata ):
for line in open( job_metadata, 'r' ):
try:
line = stringify_dictionary_keys( from_json_string( line ) )
assert line['type'] == 'dataset'
ext_override[line['dataset_id']] = line['ext']
except:
continue
for filenames in sys.argv[1:]:
filename_in, filename_kwds, filename_out, filename_results_code, dataset_filename_override = filenames.split( ',' )
try:
dataset = cPickle.load( open( filename_in ) ) #load DatasetInstance
if dataset_filename_override:
dataset.dataset.external_filename = dataset_filename_override
if ext_override.get( dataset.dataset.id, None ):
dataset.extension = ext_override[ dataset.dataset.id ]
kwds = stringify_dictionary_keys( simplejson.load( open( filename_kwds ) ) )#load kwds; need to ensure our keywords are not unicode
dataset.datatype.set_meta( dataset, **kwds )
dataset.metadata.to_JSON_dict( filename_out ) # write out results of set_meta
static/scripts/galaxy.base.js
+19 -1
View File
@@ -19,6 +19,12 @@ jQuery(document).ready( function() {
jQuery( "a[confirm]" ).click( function() {
return confirm( jQuery(this).attr( "confirm" ) )
});
// Make popup menus.
make_popup_menus();
});
function make_popup_menus()
{
jQuery( "div[popupmenu]" ).each( function() {
var options = {};
$(this).find( "a" ).each( function() {
@@ -40,7 +46,7 @@ jQuery(document).ready( function() {
$(this).remove();
b.show();
});
});
}
function ensure_popup_helper() {
// And the helper below the popup menus
@@ -103,3 +109,15 @@ function attach_popupmenu( button_element, wrapper ) {
};
$( button_element ).click( click );
};
// Returns the number of keys (elements) in an array/dictionary.
var array_length = function(an_array)
{
if (an_array.length)
return an_array.length;
var count = 0;
for (element in an_array)
count++;
return count;
};
templates/admin/forms/edit_form.mako
+1 -1
View File
@@ -85,7 +85,7 @@ $( function() {
<div class="toolForm">
<div class="toolFormTitle">Edit form definition "${form.name}"</div>
<form id="edit_form" name="edit_form" action="${h.url_for( controller='forms', action='edit', form_id=form.id )}" method="post" >
<form id="edit_form" name="edit_form" action="${h.url_for( controller='forms', action='manage', operation="Edit", id=trans.security.encode_id(form.current.id) )}" method="post" >
%for label, input in form_details:
<div class="form-row">
<label>${label}</label>
templates/admin/forms/grid.mako
+1
View File
@@ -0,0 +1 @@
<%inherit file="/grid_base.mako"/>
templates/admin/forms/manage_forms.mako
-76
View File
@@ -1,76 +0,0 @@
<%inherit file="/base.mako"/>
<%namespace file="/message.mako" import="render_msg" />
<%def name="title()">Manage Form Definitions</%def>
%if msg:
${render_msg( msg, messagetype )}
%endif
## Render a row
<%def name="render_row( form, ctr )">
%if ctr % 2 == 1:
<tr class="odd_row">
%else:
<tr>
%endif
<td>
<a href="${h.url_for( controller='forms', action='edit', form_id=form.id, read_only=True )}">${form.name}</a>
<a id="form-${form.id}-popup" class="popup-arrow" style="display: none;">&#9660;</a>
%if form.form_definition_current.deleted:
<div popupmenu="form-${form.id}-popup">
<a class="action-button" href="${h.url_for( action='undelete', form_id=form.id )}">Undelete</a>
</div>
%else:
<div popupmenu="form-${form.id}-popup">
<a class="action-button" href="${h.url_for( action='edit', form_id=form.id, show_form=True )}">Edit</a>
<a class="action-button" confirm="Click OK to delete the form ${form.name}." href="${h.url_for( action='delete', form_id=form.id )}">Delete</a>
</div>
%endif
</td>
<td><i>${form.desc}</i></td>
<td>${form.type}</td>
</tr>
</%def>
<h2>Forms</h2>
<ul class="manage-table-actions">
<li>
<a class="action-button" href="${h.url_for( controller='forms', action='new' )}">
<span>Create a new form</span></a>
</li>
</ul>
%if not all_forms:
There are no forms.
%else:
<div class="grid-header">
%for i, filter in enumerate( ['Active', 'Deleted', 'All'] ):
%if i > 0:
<span>|</span>
%endif
%if show_filter == filter:
<span class="filter"><a href="${h.url_for( controller='forms', action='manage', show_filter=filter )}"><b>${filter}</b></a></span>
%else:
<span class="filter"><a href="${h.url_for( controller='forms', action='manage', show_filter=filter )}">${filter}</a></span>
%endif
%endfor
</div>
<table class="grid">
<thead>
<tr>
<th>Name</th>
<th>Description</th>
<th>Type</th>
</tr>
</thead>
<tbody>
%for ctr, fdc in enumerate( fdc_list ):
<tr>
${render_row( fdc.latest_form, ctr )}
</tr>
%endfor
</tbody>
</table>
%endif
templates/admin/forms/show_form_read_only.mako
+2 -2
View File
@@ -66,14 +66,14 @@
<div class="toolFormTitle">${form.name} - <i> ${form.desc}</i> (${form.type})
<a id="form-${form.id}-popup" class="popup-arrow" style="display: none;">&#9660;</a>
<div popupmenu="form-${form.id}-popup">
<a class="action-button" href="${h.url_for( action='edit', form_id=form.id, show_form=True )}">Edit</a>
<a class="action-button" href="${h.url_for( controller='forms', action='manage', operation='Edit', id=trans.security.encode_id(form.current.id) )}">Edit</a>
</div>
</div>
%else:
<div class="toolFormTitle">${form.name} (${form.type})
<a id="form-${form.id}-popup" class="popup-arrow" style="display: none;">&#9660;</a>
<div popupmenu="form-${form.id}-popup">
<a class="action-button" href="${h.url_for( action='edit', form_id=form.id, show_form=True )}">Edit</a>
<a class="action-button" href="${h.url_for( controller='forms', action='manage', operation='Edit', id=trans.security.encode_id(form.current.id) )}">Edit</a>
</div>
</div>
%endif
templates/admin/requests/create_request_type.mako
+44 -48
View File
@@ -6,63 +6,59 @@
${render_msg( msg, messagetype )}
%endif
<%def name="render_state( element_count, state_name, state_desc )">
<div class="repeat-group-item">
<div class="form-row">
<label>${1+element_count}. State name:</label>
<input type="text" name="state_name_${element_count}" value="${state_name}" size="40"/>
<input type="submit" name="remove_state_button" value="Remove state ${1+element_count}"/>
</div>
<div class="form-row">
<label>Description:</label>
<input type="text" name="state_desc_${element_count}" value="${state_desc}" size="40"/>
<div class="toolParamHelp" style="clear: both;">
optional
</div>
</div>
<div style="clear: both"></div>
</div>
</%def>
<div class="toolForm">
<div class="toolFormTitle">Create a new request type</div>
%if not request_forms or not sample_forms:
%if not rt_info_widgets:
Create a request & sample form definition first to create a new request type.
%else:
<div class="toolFormBody">
<form name="create_request_type" action="${h.url_for( controller='requests_admin', action='request_type')}" method="post" >
<form name="create_request_type" action="${h.url_for( controller='requests_admin', action='create_request_type')}" method="post" >
%for rt_info in rt_info_widgets:
<div class="form-row">
<label>Name:</label>
<label>${rt_info['label']}</label>
<div style="float: left; width: 250px; margin-right: 10px;">
<input type="text" name="name" value="New Request Type" size="40"/>
${rt_info['widget'].get_html()}
</div>
<div style="clear: both"></div>
</div>
<div class="form-row">
<label>Description:</label>
<div style="float: left; width: 250px; margin-right: 10px;">
<input type="text" name="description" value="" size="40"/>
</div>
<div style="clear: both"></div>
%endfor
<div class="toolFormTitle">Possible sample states</div>
%if len(rt_states_widgets):
%for index, info in enumerate(rt_states_widgets):
${render_state( index, info[0], info[1] )}
%endfor
%endif
<div class="form-row">
<input type="submit" name="add_state_button" value="Add state"/>
</div>
<div class="form-row">
<div style="float: left; width: 250px; margin-right: 10px;">
<input type="hidden" name="new" value="submitted" size="40"/>
</div>
<div class="form-row">
<label>
Request Form definition:
</label>
<select name="request_form_id">
%for form in request_forms:
<option value="${form.id}">${form.name}</option>
%endfor
</select>
</div>
<div class="form-row">
<label>
Sample Form definition:
</label>
<select name="sample_form_id">
%for form in sample_forms:
<option value="${form.id}">${form.name}</option>
%endfor
</select>
</div>
<div class="form-row">
<label>Number of sample states:</label>
<div style="float: left; width: 250px; margin-right: 10px;">
<input type="text" size="3" name="num_states" value="1"/>
</div>
</div>
<div class="form-row">
<div style="float: left; width: 250px; margin-right: 10px;">
<input type="hidden" name="new" value="submitted" size="40"/>
</div>
<div style="clear: both"></div>
</div>
<div class="form-row">
<input type="submit" name="define_states_button" value="Define states"/>
</div>
</form>
</div>
<div style="clear: both"></div>
</div>
<div class="form-row">
<input type="submit" name="save_request_type" value="Save"/>
</div>
</form>
%endif
</div>
templates/admin/requests/grid.mako
+1 -217
View File
@@ -1,217 +1 @@
<%inherit file="/base.mako"/>
<%namespace file="/message.mako" import="render_msg" />
<%def name="title()">Browse Requests</%def>
%if message:
<p>
<div class="${message_type}message transient-message">${message}</div>
<div style="clear: both"></div>
</p>
%endif
<%def name="javascripts()">
${parent.javascripts()}
<script type="text/javascript">
## TODO: generalize and move into galaxy.base.js
$(document).ready(function() {
$(".grid").each( function() {
var grid = this;
var checkboxes = $(this).find("input.grid-row-select-checkbox");
var update = $(this).find( "span.grid-selected-count" );
$(checkboxes).each( function() {
$(this).change( function() {
var n = $(checkboxes).filter("[checked]").size();
update.text( n );
});
})
});
});
## Can this be moved into base.mako?
%if refresh_frames:
%if 'masthead' in refresh_frames:
## Refresh masthead == user changes (backward compatibility)
if ( parent.user_changed ) {
%if trans.user:
parent.user_changed( "${trans.user.email}", ${int( app.config.is_admin_user( trans.user ) )} );
%else:
parent.user_changed( null, false );
%endif
}
%endif
%if 'history' in refresh_frames:
if ( parent.frames && parent.frames.galaxy_history ) {
parent.frames.galaxy_history.location.href="${h.url_for( controller='root', action='history')}";
if ( parent.force_right_panel ) {
parent.force_right_panel( 'show' );
}
}
%endif
%if 'tools' in refresh_frames:
if ( parent.frames && parent.frames.galaxy_tools ) {
parent.frames.galaxy_tools.location.href="${h.url_for( controller='root', action='tool_menu')}";
if ( parent.force_left_panel ) {
parent.force_left_panel( 'show' );
}
}
%endif
%endif
</script>
</%def>
<%def name="stylesheets()">
<link href="${h.url_for('/static/style/base.css')}" rel="stylesheet" type="text/css" />
<style>
## Not generic to all grids -- move to base?
.count-box {
min-width: 1.1em;
padding: 5px;
border-width: 1px;
border-style: solid;
text-align: center;
display: inline-block;
}
</style>
</%def>
<div class="grid-header">
<h2>${grid.title}</h2>
%if trans.sa_session.query( trans.app.model.Request ).count():
##<span class="title">Filter:</span>
%for i, filter in enumerate( grid.standard_filters ):
%if i > 0:
<span>|</span>
%endif
%if grid.show_filter == filter.label:
<span class="filter"><a href="${h.url_for( controller='requests_admin', action='list', show_filter=filter.label )}"><b>${filter.label}</b></a></span>
%else:
<span class="filter"><a href="${h.url_for( controller='requests_admin', action='list', show_filter=filter.label )}">${filter.label}</a></span>
%endif
%endfor
%endif
</div>
<ul class="manage-table-actions">
<li>
<a class="action-button" href="${h.url_for( controller='requests_admin', action='new', select_request_type=True )}">
<img src="${h.url_for('/static/images/silk/add.png')}" />
<span>Create a new request</span></a>
</li>
</ul>
%if not len(query.all()):
There are no requests.
%else:
<form name="history_actions" action="${url()}" method="post" >
<table class="grid">
<thead>
<tr>
##<th></th>
%for column in grid.columns:
%if column.visible:
<%
href = ""
extra = ""
if column.sortable:
if sort_key == column.key:
if sort_order == "asc":
href = url( sort=( "-" + column.key ) )
extra = "&darr;"
else:
href = url( sort=( column.key ) )
extra = "&uarr;"
else:
href = url( sort=column.key )
%>
<th\
%if column.ncells > 1:
colspan="${column.ncells}"
%endif
>
%if href:
<a href="${href}">${column.label}</a>
%else:
${column.label}
%endif
<span>${extra}</span>
</th>
%endif
%endfor
<th></th>
</tr>
</thead>
<tbody>
%for i, item in enumerate( query ):
<tr \
%if current_item == item:
class="current" \
%endif
>
## Item selection column
##<td style="width: 1.5em;">
## <input type="checkbox" name="id" value=${trans.security.encode_id( item.id )} class="grid-row-select-checkbox" />
##</td>
## Data columns
%for column in grid.columns:
%if column.visible:
<%
# Link
if column.link and column.link( item ):
href = url( **column.link( item ) )
else:
href = None
# Value (coerced to list so we can loop)
value = column.get_value( trans, grid, item )
if column.ncells == 1:
value = [ value ]
%>
%for cellnum, v in enumerate( value ):
<%
# Attach popup menu?
if column.attach_popup and cellnum == 0:
extra = '<a id="grid-%d-popup" class="popup-arrow" style="display: none;">&#9660;</a>' % i
else:
extra = ""
%>
%if href:
<td><a href="${href}">${v}</a>&nbsp;${extra}</td>
%else:
<td >${v}${extra}</td>
%endif
</td>
%endfor
%endif
%endfor
## Actions column
<td>
<div popupmenu="grid-${i}-popup">
%for operation in grid.operations:
%if operation.allowed( item ):
%if operation.label == 'Submit':
<a class="action-button" confirm="More samples cannot be added to this request once it is submitted. Click OK to submit." href="${url( operation=operation.label, id=item.id )}">${operation.label}</a>
%else:
<a class="action-button" href="${url( operation=operation.label, id=item.id )}">${operation.label}</a>
%endif
%endif
%endfor
</div>
</td>
</tr>
%endfor
</tbody>
## <tfoot>
## <tr>
## <td></td>
## <td colspan="100">
## For <span class="grid-selected-count"></span> selected requests:
## %for operation in grid.operations:
## %if operation.allow_multiple:
## <input type="submit" name="operation" value="${operation.label}" class="action-button">
## %endif
## %endfor
## </td>
## </tr>
## </tfoot>
</table>
</form>
%endif
<%inherit file="/grid_base.mako"/>
templates/admin/requests/manage_request_types.mako
+1 -68
View File
@@ -1,68 +1 @@
<%inherit file="/base.mako"/>
<%namespace file="/message.mako" import="render_msg" />
<%def name="title()">request Types</%def>
%if msg:
${render_msg( msg, messagetype )}
%endif
<h2>
Request Types
</h2>
<ul class="manage-table-actions">
<li>
<a class="action-button" href="${h.url_for( controller='requests_admin', action='request_type', create=True )}"><span>Create a new request type</span></a>
</li>
</ul>
<div class="grid-header">
##<span class="title">Filter:</span>
%for i, filter in enumerate( ['Active', 'Deleted', 'All'] ):
%if i > 0:
<span>|</span>
%endif
%if show_filter == filter:
<span class="filter"><a href="${h.url_for( controller='requests_admin', action='manage_request_types', show_filter=filter )}"><b>${filter}</b></a></span>
%else:
<span class="filter"><a href="${h.url_for( controller='requests_admin', action='manage_request_types', show_filter=filter )}">${filter}</a></span>
%endif
%endfor
</div>
%if not request_types:
There are no request types.
%else:
<table class="grid">
<thead>
<tr>
<th>Name</th>
<th>Description</th>
<th>Request Form</th>
<th>Sample Form</th>
</tr>
</thead>
<tbody>
%for request_type in request_types:
<tr>
<td>
<a href="${h.url_for( controller='requests_admin', action='request_type', view='True', id=request_type.id)}">${request_type.name}</a>
<a id="request_type-${request_type.id}-popup" class="popup-arrow" style="display: none;">&#9660;</a>
%if request_type.deleted:
<div popupmenu="request_type-${request_type.id}-popup">
<a class="action-button" href="${h.url_for( action='undelete_request_type', request_type_id=request_type.id )}">Undelete</a>
</div>
%else:
<div popupmenu="request_type-${request_type.id}-popup">
<a class="action-button" confirm="Click OK to delete the request type ${request_type.name}." href="${h.url_for( action='delete_request_type', request_type_id=request_type.id )}">Delete</a>
</div>
%endif
</td>
<td><i>${request_type.desc}</i></td>
<td><a href="${h.url_for( controller='forms', action='edit', form_id=request_type.request_form.id, read_only=True)}">${request_type.request_form.name}</a></td>
<td><a href="${h.url_for( controller='forms', action='edit', form_id=request_type.sample_form.id, read_only=True)}">${request_type.sample_form.name}</a></td>
</tr>
%endfor
</tbody>
</table>
%endif
<%inherit file="/grid_base.mako"/>
templates/admin/requests/show_request.mako
+1 -1
View File
@@ -127,7 +127,7 @@
<div class="form-row">
<ul class="manage-table-actions">
<li>
<a class="action-button" href="${h.url_for( controller='requests_admin', action='edit', show=True, request_id=request.id)}">
<a class="action-button" href="${h.url_for( controller='requests_admin', action='list', operation='Edit', id=trans.security.encode_id(request.id))}">
<span>Edit request details</span></a>
</li>
</ul>
templates/admin/requests/view_request_type.mako
+32 -38
View File
@@ -7,43 +7,37 @@
%endif
<div class="toolForm">
<div class="toolFormTitle">View request type details</div>
<div class="toolFormBody">
<form name="library">
<div class="form-row">
<label>Name</label>
${request_type.name}
<div class="toolFormTitle">Request type information</div>
<form name="library">
<div class="form-row">
<label>Name</label>
${request_type.name}
<div style="clear: both"></div>
</div>
<div class="form-row">
<label>Description</label>
${request_type.desc}
<div style="clear: both"></div>
</div>
<div class="form-row">
<label>
Request Form definition
</label>
${request_type.request_form.name}
</div>
<div class="form-row">
<label>
Sample Form definition
</label>
${request_type.sample_form.name}
</div>
<div class="toolFormTitle">Possible sample states</div>
%for element_count, state in enumerate(states_list):
<div class="form-row">
<label>${1+element_count}. ${state.name}</label>
${state.desc}
</div>
<div style="clear: both"></div>
</div>
<div class="form-row">
<label>Description</label>
${request_type.desc}
<div style="clear: both"></div>
</div>
<div class="form-row">
<label>
Request Form definition
</label>
${request_type.request_form.name}
</div>
<div class="form-row">
<label>
Sample Form definition
</label>
${request_type.sample_form.name}
</div>
<div class="form-row">
<label>
Possible states
</label>
%for element_count, state in enumerate(states_list):
<div class="form-row">
<label>${1+element_count}. ${state.name}</label>
${state.desc}
</div>
<div style="clear: both"></div>
%endfor
</div>
</form>
</div>
%endfor
</form>
</div>
templates/dataset/errors.mako
+11 -6
View File
@@ -18,10 +18,10 @@
<body>
<h2>Dataset generation errors</h2>
<p><b>Dataset ${dataset.hid}: ${dataset.display_name()}</b></p>
<p><b>Dataset ${hda.hid}: ${hda.display_name()}</b></p>
%if dataset.creating_job_associations:
<% job = dataset.creating_job_associations[0].job %>
%if hda.creating_job_associations:
<% job = hda.creating_job_associations[0].job %>
%if job.traceback:
The Galaxy framework encountered the following error while attempting to run the tool:
<pre>${job.traceback}</pre>
@@ -43,7 +43,12 @@
%else:
The tool did not create any additional job / error info.
%endif
<%
if trans.user:
user_email = trans.user.email
else:
user_email = ''
%>
<h2>Report this error to the Galaxy Team</h2>
<p>
The Galaxy team regularly reviews errors that occur in the application.
@@ -56,10 +61,10 @@
<div class="toolFormTitle">Error Report</div>
<div class="toolFormBody">
<form name="report_error" action="${h.url_for( action='report_error')}" method="post" >
<input type="hidden" name="id" value="${dataset.id}" />
<input type="hidden" name="id" value="${hda.id}" />
<div class="form-row">
<label>Your email</label>
<input type="text" name="email" size="40" />
<input type="text" name="email" size="40" value="${user_email}" />
</div>
<div class="form-row">
<label>Message</label>
templates/grid_base.mako
+3 -1
View File
@@ -347,8 +347,9 @@ ${self.grid_table()}
</td>
</tr>
%endif
## Grid operations.
%if grid.operations:
<tr>
## Grid operations.
<td></td>
<td colspan="100">
For <span class="grid-selected-count"></span> selected ${items_plural}:
@@ -359,6 +360,7 @@ ${self.grid_table()}
%endfor
</td>
</tr>
%endif
</tfoot>
</table>
</form>
templates/grid_base_async.mako
+698
View File
@@ -0,0 +1,698 @@
<%!
from galaxy.web.framework.helpers.grids import TextColumn
from galaxy.model import History, HistoryDatasetAssociation, User, Role, Group
import galaxy.util
def inherit(context):
if context.get('use_panels'):
return '/base_panels.mako'
else:
return '/base.mako'
%>
<%inherit file="${inherit(context)}"/>
## Render the grid's basic elements. Each of these elements can be subclassed.
%if message:
<p>
<div class="${message_type}message transient-message">${util.restore_text( message )}</div>
<div style="clear: both"></div>
</p>
%endif
${self.render_grid_header()}
${self.render_grid_table()}
## Function definitions.
<%def name="title()">${grid.title}</%def>
<%def name="javascripts()">
${parent.javascripts()}
${h.js("jquery.autocomplete", "autocomplete_tagging" )}
<script type="text/javascript">
## TODO: generalize and move into galaxy.base.js
$(document).ready(function() {
// Initialize grid elements.
init_grid_elements();
// Operations that are not async (AJAX) compatible.
var no_async_ops = new Object();
%for operation in grid.operations:
%if not operation.async_compatible:
no_async_ops['${operation.label}'] = "True";
%endif
%endfor
// Initialize each operation button to do operation when clicked.
$('input[name=operation]:submit').each(function() {
$(this).click( function() {
var this_value = $(this).attr("value");
var no_async = ( no_async_ops[this_value] != undefined && no_async_ops[this_value] != null);
do_operation(this_value, no_async);
});
});
// Initialize autocomplete for text inputs in search UI.
var t = $("#input-tags-filter");
if (t.length)
{
var autocomplete_options =
{ selectFirst: false, autoFill: false, highlight: false, mustMatch: false };
t.autocomplete("${h.url_for( controller='tag', action='tag_autocomplete_data', item_class='History' )}", autocomplete_options);
}
var t2 = $("#input-name-filter");
if (t2.length)
{
var autocomplete_options =
{ selectFirst: false, autoFill: false, highlight: false, mustMatch: false };
t2.autocomplete("${h.url_for( controller='history', action='name_autocomplete_data' )}", autocomplete_options);
}
});
## Can this be moved into base.mako?
%if refresh_frames:
%if 'masthead' in refresh_frames:
## Refresh masthead == user changes (backward compatibility)
if ( parent.user_changed ) {
%if trans.user:
parent.user_changed( "${trans.user.email}", ${int( app.config.is_admin_user( trans.user ) )} );
%else:
parent.user_changed( null, false );
%endif
}
%endif
%if 'history' in refresh_frames:
if ( parent.frames && parent.frames.galaxy_history ) {
parent.frames.galaxy_history.location.href="${h.url_for( controller='root', action='history')}";
if ( parent.force_right_panel ) {
parent.force_right_panel( 'show' );
}
}
%endif
%if 'tools' in refresh_frames:
if ( parent.frames && parent.frames.galaxy_tools ) {
parent.frames.galaxy_tools.location.href="${h.url_for( controller='root', action='tool_menu')}";
if ( parent.force_left_panel ) {
parent.force_left_panel( 'show' );
}
}
%endif
%endif
//
// Code to handle grid operations: filtering, sorting, paging, and operations.
//
// Initialize grid elements.
function init_grid_elements()
{
$(".grid").each( function() {
var grid = this;
var checkboxes = $(this).find("input.grid-row-select-checkbox");
var update = $(this).find( "span.grid-selected-count" );
$(checkboxes).each( function() {
$(this).change( function() {
var n = $(checkboxes).filter("[checked]").size();
update.text( n );
});
})
});
}
// Filter values for categorical filters.
var categorical_filters = new Object();
%for column in grid.columns:
%if column.filterable is not None and not isinstance( column, TextColumn ):
var ${column.key}_filters =
{
%for i, filter in enumerate( column.get_accepted_filters() ):
%if i > 0:
,
%endif
${filter.label} : ${h.to_json_string( filter.args )}
%endfor
};
categorical_filters['${column.key}'] = ${column.key}_filters;
%endif
%endfor
// Initialize URL args with filter arguments.
var url_args = ${h.to_json_string( cur_filter_dict )};
// Place "f-" in front of all filter arguments.
var arg;
for (arg in url_args)
{
value = url_args[arg];
delete url_args[arg];
url_args["f-" + arg] = value;
}
// Add sort argument to URL args.
url_args['sort'] = "${encoded_sort_key}";
// Add async keyword to URL args.
url_args['async'] = true;
// Add tag to grid filter.
function add_tag_to_grid_filter(tag_name, tag_value)
{
// Put tag name and value together.
var tag = tag_name + (tag_value != null && tag_value != "" ? ":" + tag_value : "");
add_filter_condition("tags", tag, true);
}
// Add a condition to the grid filter; this adds the condition and refreshes the grid.
function add_filter_condition(name, value, append)
{
// Update URL arg with new condition.
if (append)
{
// Update or append value.
var cur_val = url_args["f-" + name];
var new_val;
if (cur_val == null || cur_val == undefined)
{
new_val = value;
}
else if (typeof(cur_val) == "string")
{
if (cur_val == "All")
new_val = value;
else
{
// Replace string with array.
var values = new Array();
values[0] = cur_val;
values[1] = value;
new_val = values;
}
}
else {
// Current value is an array.
new_val = cur_val;
new_val[new_val.length] = value;
}
url_args["f-" + name] = new_val;
}
else
{
// Replace value.
url_args["f-" + name] = value;
}
// Add button that displays filter and provides a button to delete it.
var t = $("<span>" + value +
"&nbsp;<a href='#'><img src='${h.url_for('/static/images/delete_tag_icon_gray.png')}'/></a></span>");
t.addClass('text-filter-val');
t.click(function() {
//
// Remove filter condition.
//
// TODO: remove element.
//var tag_button = $(this).parent();
$(this).remove();
// Remove condition from URL args.
var cur_val = url_args["f-" + name];
if (cur_val == null || cur_val == undefined)
{
// Unexpected. Throw error?
}
else if (typeof(cur_val) == "string")
{
if (cur_val == "All")
{
// Unexpected. Throw error?
}
else
// Remove condition.
delete url_args["f-" + name];
}
else {
// Current value is an array.
var conditions = cur_val;
var index;
for (index = 0; index < conditions.length; index++)
if (conditions[index] == value)
{
conditions.splice(index, 1);
break;
}
}
update_grid();
});
var container = $('#' + name + "-filtering-criteria");
container.append(t);
update_grid();
}
// Set sort condition for grid.
function set_sort_condition(col_key)
{
// Set new sort condition. New sort is col_key if sorting new column; if reversing sort on
// currently sorted column, sort is reversed.
var cur_sort = url_args['sort'];
var new_sort = col_key;
if ( cur_sort.indexOf( col_key ) != -1)
{
// Reverse sort.
if ( cur_sort.substring(0,1) != '-' )
new_sort = '-' + col_key;
else
{
// Sort reversed by using just col_key.
}
}
// Remove sort arrows elements.
$('.sort-arrow').remove()
// Add sort arrow element to new sort column.
var sort_arrow = "&uarr;";
if (new_sort.substring(0,1) != '-')
sort_arrow = "&darr;";
var t = $("<span>" + sort_arrow + "</span>").addClass('sort-arrow');
var th = $("#" + col_key + '-header');
th.append(t);
// Update grid.
url_args['sort'] = new_sort;
update_grid();
}
// Set new value for categorical filter.
function set_categorical_filter(this_obj, name, new_value)
{
// Update filter hyperlinks to reflect new filter value.
var category_filter = categorical_filters[name];
var cur_value = url_args["f-" + name];
$("." + name + "-filter").each( function() {
var text = $(this).text().trim();
var filter = category_filter[text];
var filter_value = filter[name];
if (filter_value == new_value)
{
// Remove filter link since grid will be using this filter. It is assumed that
// this element has a single child, a hyperlink/anchor with text.
$(this).empty();
$(this).append("<span style='font-style: italic'>" + text + "</span>");
}
else if (filter_value == cur_value)
{
// Add hyperlink for this filter since grid will no longer be using this filter. It is assumed that
// this element has a single child, a hyperlink/anchor.
$(this).empty();
var t = $("<a href='#'>" + text + "</a>");
t.click(function() {
set_categorical_filter( $(this), name, filter_value );
});
$(this).append(t);
}
});
// Need to go back to page 1 if not showing all.
var cur_page = url_args['page'];
if (cur_page != null && cur_page != undefined && cur_page != 'all')
url_args['page'] = 1;
// Update grid.
url_args["f-" + name] = new_value;
update_grid();
}
var num_pages = ${num_pages};
url_args['page'] = 1;
// Set page to view.
function set_page(new_page)
{
// Update page hyperlink to reflect new page.
$(".page-link").each( function() {
var id = $(this).attr('id');
var page_num = parseInt( id.split("-")[2] ); // Id has form 'page-link-<page_num>
var cur_page = url_args['page'];
if (page_num == new_page)
{
// Remove link to page since grid will be on this page. It is assumed that
// this element has a single child, a hyperlink/anchor with text.
var text = $(this).children().text();
$(this).empty();
$(this).addClass("inactive-link");
$(this).text(text);
}
else if (page_num == cur_page)
{
// Add hyperlink to this page since grid will no longer be on this page. It is assumed that
// this element has a single child, a hyperlink/anchor.
var text = $(this).text();
$(this).empty();
$(this).removeClass("inactive-link");
var t = $("<a href='#'>" + text + "</a>");
t.click(function() {
set_page(page_num);
});
$(this).append(t);
}
});
if (new_page == "all")
{
url_args['page'] = new_page;
$('#page-links-row').hide('slow');
}
else
{
url_args['page'] = parseInt(new_page);
}
update_grid(true);
}
// Perform a grid operation. TODO: this is not complete.
function do_operation(operation, no_async)
{
// For some reason, $('input[name=id]:checked').val() does not return all ids for checked boxes.
// The code below performs this function.
var item_ids = new Array()
$('input[name=id]:checked').each(function() {
item_ids[item_ids.length] = $(this).val();
});
// Update URL args.
url_args['operation'] = operation;
url_args['id'] = item_ids;
// If operation cannot be performed asynchronously, redirect to location. Otherwise do operation.
if (no_async)
{
var arg_str = "";
var arg;
for (arg in url_args)
arg_str = arg_str + arg + "=" + url_args[arg] + "&";
self.location = encodeURI( "${h.url_for()}?" + arg_str );
}
else
update_grid();
}
// Update grid.
function update_grid(maintain_page_links)
{
$.ajax({
url: "${h.url_for()}",
data: url_args,
error: function() { alert( "Grid refresh failed" ) },
success: function(response_text) {
// HACK: use a simple string to separate the two elements in the
// response: (1) table body and (2) number of pages in table.
var parsed_response_text = response_text.split("*****");
// Update grid body.
var table_body = parsed_response_text[0];
$('#grid-table-body').html(table_body);
// Process grid body.
init_grid_elements();
make_popup_menus();
// Update pages.
var num_pages = parseInt( parsed_response_text[1] );
// Rebuild page links.
if (!maintain_page_links)
{
var page_link_container = $('#page-link-container');
page_link_container.children().remove();
if (num_pages > 1)
{
// Show page link row.
$('#page-links-row').show();
// First page is the current page.
var t = $("<span>1</span>");
t.addClass('page-link');
t.addClass('inactive-link');
t.attr('id', 'page-link-1');
page_link_container.append(t);
// Subsequent pages are navigable.
for (var i = 2; i <= num_pages; i++)
{
var span = $("<span></span>");
span.addClass('page-link');
span.attr('id', 'page-link-' + i);
var t = $("<a href='#'>" + i + "</a>");
var page_num = i
t.click(function() {
set_page(page_num);
});
span.append(t)
page_link_container.append(span);
}
}
else
{
// Hide page link row.
$('#page-links-row').hide('slow');
}
}
}
});
}
</script>
</%def>
<%def name="stylesheets()">
${h.css( "base", "autocomplete_tagging" )}
<style>
## Not generic to all grids -- move to base?
.count-box {
min-width: 1.1em;
padding: 5px;
border-width: 1px;
border-style: solid;
text-align: center;
display: inline-block;
}
.text-filter-val {
border: solid 1px #AAAAAA;
padding: 1px 3px 1px 3px;
margin-right: 5px;
-moz-border-radius: .5em;
-webkit-border-radius: .5em;
font-style: italic;
}
.page-link a, .inactive-link {
padding: 0px 7px 0px 7px;
}
.inactive-link {
font-style: italic;
}
</style>
</%def>
<%namespace file="./grid_common_async.mako" import="*" />
## Print grid header.
<%def name="render_grid_header()">
<div class="grid-header">
<h2>${grid.title}</h2>
%if grid.global_actions:
<ul class="manage-table-actions">
%for action in grid.global_actions:
<li>
<a class="action-button" href="${h.url_for( **action.url_args )}">${action.label}</a>
</li>
%endfor
</ul>
%endif
${render_grid_filters()}
</div>
</%def>
## Print grid.
<%def name="render_grid_table()">
<form action="${url()}" method="post" onsubmit="return false;">
<table class="grid">
<thead id="grid-table-header">
<tr>
<th></th>
%for column in grid.columns:
%if column.visible:
<%
href = ""
extra = ""
if column.sortable:
if sort_key == column.key:
if sort_order == "asc":
href = url( sort=( "-" + column.key ) )
extra = "&darr;"
else:
href = url( sort=( column.key ) )
extra = "&uarr;"
else:
href = url( sort=column.key )
%>
<th\
id="${column.key}-header"
%if column.ncells > 1:
colspan="${column.ncells}"
%endif
>
%if href:
<a href="${href}" onclick="set_sort_condition('${column.key}');return false;">${column.label}</a>
%else:
${column.label}
%endif
<span class="sort-arrow">${extra}</span>
</th>
%endif
%endfor
<th></th>
</tr>
</thead>
<tbody id="grid-table-body">
${render_grid_table_body_contents()}
</tbody>
<tfoot id="grid-table-footer">
${render_grid_table_footer_contents()}
</tfoot>
</table>
</form>
</%def>
<%def name="render_grid_table_body_contents()">
%if query.count() == 0:
## No results.
<tr><td></td><td><em>No Items</em></td></tr>
%endif
%for i, item in enumerate( query ):
<tr \
%if current_item == item:
class="current" \
%endif
>
## Item selection column
<td style="width: 1.5em;">
<input type="checkbox" name="id" value=${trans.security.encode_id( item.id )} class="grid-row-select-checkbox" />
</td>
## Data columns
%for column in grid.columns:
%if column.visible:
<%
# Link
link = column.get_link( trans, grid, item )
if link:
href = url( **link )
else:
href = None
# Value (coerced to list so we can loop)
value = column.get_value( trans, grid, item )
if column.ncells == 1:
value = [ value ]
%>
%for cellnum, v in enumerate( value ):
<%
# Handle non-ascii chars.
if isinstance(v, str):
v = unicode(v, 'utf-8')
# Attach popup menu?
if column.attach_popup and cellnum == 0:
extra = '<a id="grid-%d-popup" class="arrow" style="display: none;"><span>&#9660;</span></a>' % i
else:
extra = ""
%>
%if href:
<td><div class="menubutton split" style="float: left;"><a class="label" href="${href}">${v}</a>${extra}</td>
%else:
<td >${v}${extra}</td>
%endif
%endfor
%endif
%endfor
## Actions column
<td>
<div popupmenu="grid-${i}-popup">
%for operation in grid.operations:
%if operation.allowed( item ):
<%
target = ""
if operation.target:
target = "target='" + operation.target + "'"
%>
<a class="action-button" ${target} href="${ url( **operation.get_url_args( item ) ) }">${operation.label}</a>
%endif
%endfor
</div>
</td>
</tr>
%endfor
</%def>
<%def name="render_grid_table_footer_contents()">
## Row for navigating among pages.
<%
# Mapping between item class and plural term for item.
items_plural = "items"
if grid.model_class == History:
items_plural = "histories"
elif grid.model_class == HistoryDatasetAssociation:
items_plural = "datasets"
elif grid.model_class == User:
items_plural = "users"
elif grid.model_class == Role:
items_plural = "roles"
elif grid.model_class == Group:
items_plural = "groups"
%>
%if num_pages > 1:
<tr id="page-links-row">
<td></td>
<td colspan="100">
<span id='page-link-container'>
## Page links.
Page:
%for page_index in range(1, num_pages + 1):
%if page_index == cur_page_num:
<span class='page-link inactive-link' id="page-link-${page_index}">${page_index}</span>
%else:
<% args = { 'page' : page_index } %>
<span class='page-link' id="page-link-${page_index}"><a href="${url( args )}" onclick="set_page('${page_index}'); return false;">${page_index}</a></span>
%endif
%endfor
</span>
## Show all link.
<% args = { "page" : "all" } %>
<span id='show-all-link'>| <a href="${url( args )}" onclick="set_page('all');return false;">Show all ${items_plural} on one page</a></span>
</td>
</tr>
%endif
## Grid operations.
%if grid.operations:
<tr>
<td></td>
<td colspan="100">
For <span class="grid-selected-count"></span> selected ${items_plural}:
%for operation in grid.operations:
%if operation.allow_multiple:
<input type="submit" name="operation" value="${operation.label}" class="action-button">
%endif
%endfor
</td>
</tr>
%endif
</%def>
templates/grid_body_async.mako
+5
View File
@@ -0,0 +1,5 @@
<%namespace file="./grid_base_async.mako" import="*" />
${render_grid_table_body_contents()}
*****
${num_pages}
templates/grid_common_async.mako
+155
View File
@@ -0,0 +1,155 @@
<%! from galaxy.web.framework.helpers.grids import TextColumn, GridColumnFilter %>
## Render an AJAX filter UI for a grid column. Filter is rendered as a table row.
<%def name="render_ajax_grid_column_filter(column)">
<tr>
<%
column_label = column.label
if column.filterable == "advanced":
column_label = column_label.lower()
%>
<td align="left" style="padding-left: 10px">${column_label}:</td>
<td>
%if isinstance(column, TextColumn):
<form action="${url( dict() )}" id="form-filter-${column.key}"
## Move this to doc.ready()
##onsubmit="var text_input=$('#input-${column.key}-filter').val();$('#input-${column.key}-filter').val('');add_filter_condition('${column.key}',text_input,true);return false;"
onsubmit="var text_input=$('#input-${column.key}-filter').val();$('#input-${column.key}-filter').val('');add_filter_condition('${column.key}',text_input,true);return false;"
method="get" >
## Carry forward filtering criteria with hidden inputs.
%for temp_column in grid.columns:
%if temp_column.key in cur_filter_dict:
<% value = cur_filter_dict[ temp_column.key ] %>
%if value != "All":
<%
if isinstance( temp_column, TextColumn ):
value = h.to_json_string( value )
%>
<input type="hidden" id="${temp_column.key}" name="f-${temp_column.key}" value='${value}'/>
%endif
%endif
%endfor
## Print current filtering criteria and links to delete.
<span id="${column.key}-filtering-criteria">
%if column.key in cur_filter_dict:
<% column_filter = cur_filter_dict[column.key] %>
%if isinstance( column_filter, basestring ):
%if column_filter != "All":
<span style="font-style: italic">${cur_filter_dict[column.key]}</span>
<% filter_all = GridColumnFilter( "", { column.key : "All" } ) %>
<a href="${url( filter_all.get_url_args() )}"><img src="${h.url_for('/static/images/delete_tag_icon_gray.png')}"/></a>
|
%endif
%elif isinstance( column_filter, list ):
%for i, filter in enumerate( column_filter ):
%if i > 0:
,
%endif
<span style="font-style: italic">${filter}</span>
<%
new_filter = list( column_filter )
del new_filter[ i ]
new_column_filter = GridColumnFilter( "", { column.key : h.to_json_string( new_filter ) } )
%>
<a href="${url( new_column_filter.get_url_args() )}"><img src="${h.url_for('/static/images/delete_tag_icon_gray.png')}"/></a>
%endfor
%endif
%endif
</span>
## Print input field for column.
<span><input id="input-${column.key}-filter" name="f-${column.key}" type="text" value="" size="15"/></span>
</form>
%else:
<span id="${column.key}-filtering-criteria">
%for i, filter in enumerate( column.get_accepted_filters() ):
<%
# HACK: we know that each filter will have only a single argument, so get that single argument.
for key, arg in filter.args.items():
filter_key = key
filter_arg = arg
%>
%if i > 0:
|
%endif
%if column.key in cur_filter_dict and column.key in filter.args and cur_filter_dict[column.key] == filter.args[column.key]:
<span class="${column.key}-filter">${filter.label}</span>
%else:
<span class="${column.key}-filter">
<a href="${url( filter.get_url_args() )}"
onclick="set_categorical_filter($(this), '${column.key}','${filter_arg}'); return false;">${filter.label}</a>
</span>
%endif
%endfor
</span>
%endif
</td>
</tr>
</%def>
## Print grid search/filtering UI.
<%def name="render_grid_filters()">
## Standard search.
<div>
<table><tr>
<td>
<table>
%for column in grid.columns:
%if column.filterable == "standard":
${render_ajax_grid_column_filter(column)}
%endif
%endfor
</table>
</td>
<td>
## Clear the standard search.
##|
##<% filter_all = GridColumnFilter( "", { column.key : "All" } ) %>
##<a href="${url( filter_all.get_url_args() )}">Clear All</a>
## Only show advanced search if there are filterable columns.
<%
show_advanced_search = False
for column in grid.columns:
if column.filterable == "advanced":
show_advanced_search = True
break
endif
%>
%if show_advanced_search:
| <a href="" onclick="javascript:$('#more-search-options').slideToggle('fast');return false;">Advanced Search</a>
%endif
</td>
</tr></table>
</div>
## Advanced search.
<div id="more-search-options" style="display: none; padding-top: 5px">
<table style="border: 1px solid gray;">
<tr><td style="text-align: left" colspan="100">
Advanced Search |
<a href=""# onclick="javascript:$('#more-search-options').slideToggle('fast');return false;">Close</a> |
## Link to clear all filters.
<%
no_filter = GridColumnFilter("Clear All", default_filter_dict)
%>
<a href="${url( no_filter.get_url_args() )}">${no_filter.label}</a>
</td></tr>
%for column in grid.columns:
%if column.filterable == "advanced":
## Show div if current filter has value that is different from the default filter.
%if column.key in cur_filter_dict and column.key in default_filter_dict and \
cur_filter_dict[column.key] != default_filter_dict[column.key]:
<script type="text/javascript">
$('#more-search-options').css("display", "block");
</script>
%endif
${render_ajax_grid_column_filter(column)}
%endif
%endfor
</table>
</div>
</%def>
templates/mobile/history/detail.mako
+1 -1
View File
@@ -37,7 +37,7 @@
<div class="secondary">
## Body for history items, extra info and actions, data "peek"
<% user, roles = trans.get_user_and_roles() %>
%if not trans.app.security_agent.can_access_dataset( roles, data.dataset ):
%if not trans.user_is_admin() and not trans.app.security_agent.can_access_dataset( roles, data.dataset ):
<div>You do not have permission to view this dataset.</div>
%elif data_state == "queued":
<div>Job is waiting to run</div>
templates/requests/grid.mako
+1 -217
View File
@@ -1,217 +1 @@
<%inherit file="/base.mako"/>
<%namespace file="/message.mako" import="render_msg" />
<%def name="title()">Browse Samples</%def>
%if message:
<p>
<div class="${message_type}message transient-message">${message}</div>
<div style="clear: both"></div>
</p>
%endif
<%def name="javascripts()">
${parent.javascripts()}
<script type="text/javascript">
## TODO: generalize and move into galaxy.base.js
$(document).ready(function() {
$(".grid").each( function() {
var grid = this;
var checkboxes = $(this).find("input.grid-row-select-checkbox");
var update = $(this).find( "span.grid-selected-count" );
$(checkboxes).each( function() {
$(this).change( function() {
var n = $(checkboxes).filter("[checked]").size();
update.text( n );
});
})
});
});
## Can this be moved into base.mako?
%if refresh_frames:
%if 'masthead' in refresh_frames:
## Refresh masthead == user changes (backward compatibility)
if ( parent.user_changed ) {
%if trans.user:
parent.user_changed( "${trans.user.email}", ${int( app.config.is_admin_user( trans.user ) )} );
%else:
parent.user_changed( null, false );
%endif
}
%endif
%if 'history' in refresh_frames:
if ( parent.frames && parent.frames.galaxy_history ) {
parent.frames.galaxy_history.location.href="${h.url_for( controller='root', action='history')}";
if ( parent.force_right_panel ) {
parent.force_right_panel( 'show' );
}
}
%endif
%if 'tools' in refresh_frames:
if ( parent.frames && parent.frames.galaxy_tools ) {
parent.frames.galaxy_tools.location.href="${h.url_for( controller='root', action='tool_menu')}";
if ( parent.force_left_panel ) {
parent.force_left_panel( 'show' );
}
}
%endif
%endif
</script>
</%def>
<%def name="stylesheets()">
<link href="${h.url_for('/static/style/base.css')}" rel="stylesheet" type="text/css" />
<style>
## Not generic to all grids -- move to base?
.count-box {
min-width: 1.1em;
padding: 5px;
border-width: 1px;
border-style: solid;
text-align: center;
display: inline-block;
}
</style>
</%def>
<div class="grid-header">
<h2>${grid.title}</h2>
%if len(trans.user.requests):
##<span class="title">Filter:</span>
%for i, filter in enumerate( grid.standard_filters ):
%if i > 0:
<span>|</span>
%endif
%if grid.show_filter == filter.label:
<span class="filter"><a href="${h.url_for( controller='requests', action='list', show_filter=filter.label )}"><b>${filter.label}</b></a></span>
%else:
<span class="filter"><a href="${h.url_for( controller='requests', action='list', show_filter=filter.label )}">${filter.label}</a></span>
%endif
%endfor
%endif
</div>
<ul class="manage-table-actions">
<li>
<a class="action-button" href="${h.url_for( controller='requests', action='new', select_request_type=True )}">
<img src="${h.url_for('/static/images/silk/add.png')}" />
<span>Create a new request</span></a>
</li>
</ul>
%if not len(query.all()):
There are no request(s).
%else:
<form name="history_actions" action="${url()}" method="post" >
<table class="grid">
<thead>
<tr>
##<th></th>
%for column in grid.columns:
%if column.visible:
<%
href = ""
extra = ""
if column.sortable:
if sort_key == column.key:
if sort_order == "asc":
href = url( sort=( "-" + column.key ) )
extra = "&darr;"
else:
href = url( sort=( column.key ) )
extra = "&uarr;"
else:
href = url( sort=column.key )
%>
<th\
%if column.ncells > 1:
colspan="${column.ncells}"
%endif
>
%if href:
<a href="${href}">${column.label}</a>
%else:
${column.label}
%endif
<span>${extra}</span>
</th>
%endif
%endfor
<th></th>
</tr>
</thead>
<tbody>
%for i, item in enumerate( query ):
<tr \
%if current_item == item:
class="current" \
%endif
>
## Item selection column
##<td style="width: 1.5em;">
## <input type="checkbox" name="id" value=${trans.security.encode_id( item.id )} class="grid-row-select-checkbox" />
##</td>
## Data columns
%for column in grid.columns:
%if column.visible:
<%
# Link
if column.link and column.link( item ):
href = url( **column.link( item ) )
else:
href = None
# Value (coerced to list so we can loop)
value = column.get_value( trans, grid, item )
if column.ncells == 1:
value = [ value ]
%>
%for cellnum, v in enumerate( value ):
<%
# Attach popup menu?
if column.attach_popup and cellnum == 0:
extra = '<a id="grid-%d-popup" class="popup-arrow" style="display: none;">&#9660;</a>' % i
else:
extra = ""
%>
%if href:
<td><a href="${href}">${v}</a>&nbsp;${extra}</td>
%else:
<td >${v}${extra}</td>
%endif
</td>
%endfor
%endif
%endfor
## Actions column
<td>
<div popupmenu="grid-${i}-popup">
%for operation in grid.operations:
%if operation.allowed( item ):
%if operation.label == 'Submit':
<a class="action-button" confirm="More samples cannot be added to this request once it is submitted. Click OK to submit." href="${url( operation=operation.label, id=item.id)}">${operation.label}</a>
%else:
<a class="action-button" href="${url( operation=operation.label, id=item.id )}">${operation.label}</a>
%endif
%endif
%endfor
</div>
</td>
</tr>
%endfor
</tbody>
<tfoot>
## <tr>
## <td></td>
## <td colspan="100">
## For <span class="grid-selected-count"></span> selected requests:
## %for operation in grid.operations:
## %if operation.allow_multiple:
## <input type="submit" name="operation" value="${operation.label}" class="action-button">
## %endif
## %endfor
## </td>
## </tr>
</tfoot>
</table>
</form>
%endif
<%inherit file="/grid_base.mako"/>
templates/requests/show_request.mako
+1 -1
View File
@@ -119,7 +119,7 @@
<div class="form-row">
<ul class="manage-table-actions">
<li>
<a class="action-button" href="${h.url_for( controller='requests', action='edit', show=True, request_id=request.id)}">
<a class="action-button" href="${h.url_for( controller='requests', action='list', operation='Edit', id=trans.security.encode_id(request.id) )}">
<span>Edit request details</span></a>
</li>
</ul>
templates/root/history_common.mako
+2 -2
View File
@@ -9,7 +9,7 @@
data_state = data.state
user, roles = trans.get_user_and_roles()
%>
%if not trans.app.security_agent.can_access_dataset( roles, data.dataset ):
%if not trans.user_is_admin() and not trans.app.security_agent.can_access_dataset( roles, data.dataset ):
<div class="historyItemWrapper historyItem historyItem-${data_state} historyItem-noPermission" id="historyItem-${data.id}">
%else:
<div class="historyItemWrapper historyItem historyItem-${data_state}" id="historyItem-${data.id}">
@@ -49,7 +49,7 @@
## Body for history items, extra info and actions, data "peek"
<div id="info${data.id}" class="historyItemBody">
%if not trans.app.security_agent.can_access_dataset( roles, data.dataset ):
%if not trans.user_is_admin() and not trans.app.security_agent.can_access_dataset( roles, data.dataset ):
<div>You do not have permission to view this dataset.</div>
%elif data_state == "upload":
<div>Dataset is uploading</div>
templates/tagging_common.mako
-13
View File
@@ -23,19 +23,6 @@
else: ## isInstance( tag_name, unicode ):
tag_names_and_values[tag_name] = tag_value
%>
//
// Returns the number of keys (elements) in an array/dictionary.
//
var array_length = function(an_array)
{
if (an_array.length)
return an_array.length;
var count = 0;
for (element in an_array)
count++;
return count;
};
//
// Default function get text to display on the toggle link.
templates/tool_form.mako
+11 -5
View File
@@ -221,11 +221,17 @@ function checkUncheckAll( name, check )
%if tool.help:
<div class="toolHelp">
<div class="toolHelpBody">
%if tool.has_multiple_pages:
${tool.help_by_page[tool_state.page]}
%else:
${tool.help}
%endif
<%
if tool.has_multiple_pages:
tool_help = tool.help_by_page[tool_state.page]
else:
tool_help = tool.help
# Convert to unicode to display non-ascii characters.
if type( tool_help ) is not unicode:
tool_help = unicode( tool_help, 'utf-8')
%>
${tool_help}
</div>
</div>
%endif
test/base/twilltestcase.py
+29 -14
View File
@@ -10,6 +10,7 @@ from twill.other_packages._mechanize_dist import ClientForm
pkg_resources.require( "elementtree" )
from elementtree import ElementTree
from galaxy.web import security
from galaxy.web.framework.helpers import iff
buffer = StringIO.StringIO()
@@ -180,7 +181,7 @@ class TwillTestCase( unittest.TestCase ):
num_deleted = len( id.split( ',' ) )
self.home()
self.visit_page( "history/list?operation=delete&id=%s" % ( id ) )
check_str = 'Deleted %d histories' % num_deleted
check_str = 'Deleted %d %s' % ( num_deleted, iff( num_deleted != 1, "histories","history") )
self.check_page_for_string( check_str )
self.home()
def delete_current_history( self, check_str='' ):
@@ -429,6 +430,12 @@ class TwillTestCase( unittest.TestCase ):
if check_str:
self.check_page_for_string( check_str )
self.home()
def view_history( self, history_id, check_str='' ):
"""Displays a history for viewing"""
self.visit_url( '%s/history/view?id=%s' % ( self.url, self.security.encode_id( history_id ) ) )
if check_str:
self.check_page_for_string( check_str )
self.home()
def edit_hda_attribute_info( self, hda_id, new_name='', new_info='', new_dbkey='', new_startcol='' ):
"""Edit history_dataset_association attribute information"""
self.home()
@@ -1162,24 +1169,24 @@ class TwillTestCase( unittest.TestCase ):
self.check_page_for_string( desc )
self.check_page_for_string( formtype )
self.home()
def edit_form( self, form_id, form_name, new_form_name="Form One's Name (Renamed)", new_form_desc="This is Form One's description (Re-described)"):
def edit_form( self, form_current_id, form_name, new_form_name="Form One's Name (Renamed)", new_form_desc="This is Form One's description (Re-described)"):
"""
Edit form details; name & description
"""
self.home()
self.visit_url( "%s/forms/edit?form_id=%i&show_form=True" % (self.url, form_id) )
self.visit_url( "%s/forms/manage?sort=create_time&f-name=All&f-desc=All&f-deleted=False&operation=Edit&id=%s" % ( self.url, self.security.encode_id(form_current_id) ) )
self.check_page_for_string( 'Edit form definition "%s"' % form_name )
tc.fv( "1", "name", new_form_name )
tc.fv( "1", "description", new_form_desc )
tc.submit( "save_changes_button" )
self.check_page_for_string( "The form '%s' has been updated with the changes." % new_form_name )
self.home()
def form_add_field( self, form_id, form_name, form_desc, form_type, field_index, fields):
def form_add_field( self, form_current_id, form_name, form_desc, form_type, field_index, fields):
"""
Add a new fields to the form definition
"""
self.home()
self.visit_url( "%s/forms/edit?form_id=%i&show_form=True" % (self.url, form_id) )
self.visit_url( "%s/forms/manage?sort=create_time&f-name=All&f-desc=All&f-deleted=False&operation=Edit&id=%s" % ( self.url, self.security.encode_id(form_current_id) ) )
self.check_page_for_string( 'Edit form definition "%s"' % form_name)
for i, field in enumerate(fields):
index = i+field_index
@@ -1191,8 +1198,8 @@ class TwillTestCase( unittest.TestCase ):
if field['type'] == 'SelectField':
options = ''
for option_index, option in enumerate(field['selectlist']):
url_str = "%s/forms/edit?description=%s&form_id=%i&form_type_selectbox=%s&addoption_%i=Add&name=%s&field_name_%i=%s&field_helptext_%i=%s&field_type_%i=%s" % \
(self.url, form_desc.replace(" ", "+"), form_id, form_type.replace(" ", "+"),
url_str = "%s/forms/manage?operation=Edit&description=%s&id=%s&form_type_selectbox=%s&addoption_%i=Add&name=%s&field_name_%i=%s&field_helptext_%i=%s&field_type_%i=%s" % \
(self.url, form_desc.replace(" ", "+"), self.security.encode_id(form_current_id), form_type.replace(" ", "+"),
index, form_name.replace(" ", "+"), index, field['name'].replace(" ", "+"),
index, field['desc'].replace(" ", "+"), index, field['type'])
self.visit_url( url_str + options )
@@ -1207,7 +1214,7 @@ class TwillTestCase( unittest.TestCase ):
Remove a field from the form definition
"""
self.home()
self.visit_url( "%s/forms/edit?form_id=%i&show_form=True" % (self.url, form_id) )
self.visit_url( "%s/forms/manage?operation=Edit&form_id=%i&show_form=True" % (self.url, form_id) )
self.check_page_for_string( 'Edit form definition "%s"' % form_name)
tc.submit( "remove_button" )
tc.submit( "save_changes_button" )
@@ -1215,18 +1222,26 @@ class TwillTestCase( unittest.TestCase ):
self.check_page_for_string( check_str )
self.home()
# Requests stuff
def check_request_grid(self, state, request_name, deleted=False):
self.home()
self.visit_url('%s/requests/list?sort=create_time&f-state=%s&f-deleted=%s' \
% (self.url, state, str(deleted)))
self.check_page_for_string( request_name )
def check_request_admin_grid(self, state, request_name, deleted=False):
self.home()
self.visit_url('%s/requests_admin/list?sort=create_time&f-state=%s&f-deleted=%s' \
% (self.url, state, str(deleted)))
self.check_page_for_string( request_name )
def create_request_type( self, name, desc, request_form_id, sample_form_id, states ):
self.home()
self.visit_url( "%s/requests_admin/request_type?create=True" % self.url )
self.visit_url( "%s/requests_admin/create_request_type" % self.url )
self.check_page_for_string( 'Create a new request type' )
tc.fv( "1", "name", name )
tc.fv( "1", "description", desc )
tc.fv( "1", "desc", desc )
tc.fv( "1", "request_form_id", request_form_id )
tc.fv( "1", "sample_form_id", sample_form_id )
tc.fv( "1", "num_states", str( len( states ) ) )
tc.submit( "define_states_button" )
self.check_page_for_string( "Create %i states for the '%s' request type" % ( len(states), name ))
for index, state in enumerate(states):
tc.submit( "add_state_button" )
tc.fv("1", "state_name_%i" % index, state[0])
tc.fv("1", "state_desc_%i" % index, state[1])
tc.submit( "save_request_type" )
@@ -1248,7 +1263,7 @@ class TwillTestCase( unittest.TestCase ):
self.check_page_for_string( desc )
def edit_request( self, request_id, name, new_name, new_desc, new_library_id, new_folder_id, new_fields):
self.home()
self.visit_url( "%s/requests/edit?request_id=%i&show=True" % (self.url, request_id) )
self.visit_url( "%s/requests/list?operation=Edit&id=%s" % (self.url, self.security.encode_id(request_id) ) )
self.check_page_for_string( 'Edit request "%s"' % name )
tc.fv( "1", "name", new_name )
tc.fv( "1", "desc", new_desc )
test/functional/test_forms_and_requests.py
+16 -28
View File
@@ -29,6 +29,7 @@ def get_latest_form(form_name):
.filter( galaxy.model.FormDefinitionCurrent.table.c.deleted==False ) \
.order_by( galaxy.model.FormDefinitionCurrent.table.c.create_time.desc() )
for fdc in fdc_list:
sa_session.refresh( fdc )
sa_session.refresh( fdc.latest_form )
if form_name == fdc.latest_form.name:
return fdc.latest_form
@@ -51,7 +52,7 @@ class TestFormsAndRequests( TwillTestCase ):
# edit form & add few more fields
new_name = "Request Form (Renamed)"
new_desc = "This is Form One's Re-described"
self.edit_form( form_one.id, form_one.name, new_form_name=new_name, new_form_desc=new_desc )
self.edit_form( form_one.current.id, form_one.name, new_form_name=new_name, new_form_desc=new_desc )
self.home()
self.visit_page( 'forms/manage' )
self.check_page_for_string( new_name )
@@ -73,13 +74,13 @@ class TestFormsAndRequests( TwillTestCase ):
type='TextField',
required='required')]
form_one = get_latest_form(form_one_name)
self.form_add_field(form_one.id, form_one.name, form_one.desc, form_one.type, field_index=len(form_one.fields), fields=fields)
form_one_latest = get_latest_form(form_one_name)
self.form_add_field(form_one.current.id, form_one.name, form_one.desc, form_one.type, field_index=len(form_one.fields), fields=fields)
form_one_latest = get_latest_form(form_one_name)
assert len(form_one_latest.fields) == len(form_one.fields)+len(fields)
def test_015_create_sample_form( self ):
"""Testing creating another form (for samples)"""
global form_two_name
desc = "This is Form One's description"
desc = "This is Form Two's description"
formtype = 'Sequencing Sample Form'
self.create_form( name=form_two_name, desc=desc, formtype=formtype )
self.home()
@@ -207,16 +208,12 @@ class TestFormsAndRequests( TwillTestCase ):
request_one.desc+' (Re-described)', library_one.id, folder_one.id, fields)
sa_session.refresh( request_one )
# check if the request is showing in the 'unsubmitted' filter
self.home()
self.visit_url( '%s/requests/list?show_filter=Unsubmitted' % self.url )
self.check_page_for_string( request_one.name )
self.check_request_grid(state='Unsubmitted', request_name=request_one.name)
# submit the request
self.submit_request( request_one.id, request_one.name )
sa_session.refresh( request_one )
# check if the request is showing in the 'submitted' filter
self.home()
self.visit_url( '%s/requests/list?show_filter=Submitted' % self.url )
self.check_page_for_string( request_one.name )
self.check_request_grid(state='Submitted', request_name=request_one.name)
# check if the request's state is now set to 'submitted'
assert request_one.state is not request_one.states.SUBMITTED, "The state of the request '%s' should be set to '%s'" \
% ( request_one.name, request_one.states.SUBMITTED )
@@ -225,9 +222,7 @@ class TestFormsAndRequests( TwillTestCase ):
# goto admin manage requests page
self.logout()
self.login( email='test@bx.psu.edu' )
self.home()
self.visit_page( 'requests_admin/list' )
self.check_page_for_string( request_one.name )
self.check_request_admin_grid(state='Submitted', request_name=request_one.name)
self.visit_url( "%s/requests_admin/list?sort=-create_time&operation=show_request&id=%s" \
% ( self.url, self.security.encode_id( request_one.id ) ))
self.check_page_for_string( 'Sequencing Request "%s"' % request_one.name )
@@ -240,9 +235,10 @@ class TestFormsAndRequests( TwillTestCase ):
self.change_sample_state( sample.name, sample.id, request_type.states[2].id, request_type.states[2].name )
self.home()
sa_session.refresh( request_one )
self.logout()
self.login( email='test1@bx.psu.edu' )
# check if the request's state is now set to 'complete'
self.visit_url('%s/requests_admin/list?show_filter=Complete' % self.url)
self.check_page_for_string( request_one.name )
self.check_request_grid(state='Complete', request_name=request_one.name)
assert request_one.state is not request_one.states.COMPLETE, "The state of the request '%s' should be set to '%s'" \
% ( request_one.name, request_one.states.COMPLETE )
def test_040_admin_create_request_on_behalf_of_regular_user( self ):
@@ -262,9 +258,7 @@ class TestFormsAndRequests( TwillTestCase ):
galaxy.model.Request.table.c.deleted==False ) ) \
.first()
# check if the request is showing in the 'unsubmitted' filter
self.home()
self.visit_url( '%s/requests_admin/list?show_filter=Unsubmitted' % self.url )
self.check_page_for_string( request_two.name )
self.check_request_admin_grid(state='Unsubmitted', request_name=request_two.name)
# check if the request's state is now set to 'unsubmitted'
assert request_two.state is not request_two.states.UNSUBMITTED, "The state of the request '%s' should be set to '%s'" \
% ( request_two.name, request_two.states.UNSUBMITTED )
@@ -277,17 +271,13 @@ class TestFormsAndRequests( TwillTestCase ):
self.submit_request_as_admin( request_two.id, request_two.name )
sa_session.refresh( request_two )
# check if the request is showing in the 'submitted' filter
self.home()
self.visit_url( '%s/requests_admin/list?show_filter=Submitted' % self.url )
self.check_page_for_string( request_two.name )
self.check_request_admin_grid(state='Submitted', request_name=request_two.name)
# check if the request's state is now set to 'submitted'
assert request_two.state is not request_two.states.SUBMITTED, "The state of the request '%s' should be set to '%s'" \
% ( request_two.name, request_two.states.SUBMITTED )
# check if both the requests is showing in the 'All' filter
self.home()
self.visit_url( '%s/requests_admin/list?show_filter=All' % self.url )
self.check_page_for_string( request_one.name )
self.check_page_for_string( request_two.name )
self.check_request_admin_grid(state='All', request_name=request_one.name)
self.check_request_admin_grid(state='All', request_name=request_two.name)
def test_045_reject_request( self ):
'''Testing rejecting a request'''
self.logout()
@@ -295,9 +285,7 @@ class TestFormsAndRequests( TwillTestCase ):
self.reject_request( request_two.id, request_two.name )
sa_session.refresh( request_two )
# check if the request is showing in the 'unsubmitted' filter
self.home()
self.visit_url( '%s/requests_admin/list?show_filter=Unsubmitted' % self.url )
self.check_page_for_string( request_two.name )
self.check_request_admin_grid(state='Unsubmitted', request_name=request_two.name)
# check if the request's state is now set to 'submitted'
assert request_two.state is not request_two.states.UNSUBMITTED, "The state of the request '%s' should be set to '%s'" \
% ( request_two.name, request_two.states.UNSUBMITTED )
test/functional/test_get_data.py
+515 -105
View File
@@ -4,128 +4,538 @@ from galaxy.model.mapping import context as sa_session
from base.twilltestcase import TwillTestCase
class UploadData( TwillTestCase ):
def test_000_upload_files_from_disk( self ):
"""Test uploading data files from disk"""
def test_0005_upload_file( self ):
"""Test uploading 1.bed, NOT setting the file format"""
self.logout()
self.login( email='test@bx.psu.edu' )
global admin_user
admin_user = sa_session.query( galaxy.model.User ) \
.filter( galaxy.model.User.table.c.email=='test@bx.psu.edu' ) \
.one()
history1 = sa_session.query( galaxy.model.History ) \
.filter( and_( galaxy.model.History.table.c.deleted==False,
galaxy.model.History.table.c.user_id==admin_user.id ) ) \
.order_by( desc( galaxy.model.History.table.c.create_time ) ) \
.first()
history = sa_session.query( galaxy.model.History ) \
.filter( and_( galaxy.model.History.table.c.deleted==False,
galaxy.model.History.table.c.user_id==admin_user.id ) ) \
.order_by( desc( galaxy.model.History.table.c.create_time ) ) \
.first()
self.upload_file( '1.bed' )
hda1 = sa_session.query( galaxy.model.HistoryDatasetAssociation ) \
.order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ) \
.first()
assert hda1 is not None, "Problem retrieving hda1 from database"
self.verify_dataset_correctness( '1.bed', hid=str( hda1.hid ) )
self.upload_file( '2.bed', dbkey='hg17' )
hda2 = sa_session.query( galaxy.model.HistoryDatasetAssociation ) \
.order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ) \
.first()
assert hda2 is not None, "Problem retrieving hda2 from database"
self.verify_dataset_correctness( '2.bed', hid=str( hda2.hid ) )
self.upload_file( '3.bed', dbkey='hg17', ftype='bed' )
hda3 = sa_session.query( galaxy.model.HistoryDatasetAssociation ) \
.order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ) \
.first()
assert hda3 is not None, "Problem retrieving hda3 from database"
self.verify_dataset_correctness( '3.bed', hid=str( hda3.hid ) )
hda = sa_session.query( galaxy.model.HistoryDatasetAssociation ) \
.order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ) \
.first()
assert hda is not None, "Problem retrieving hda from database"
self.verify_dataset_correctness( '1.bed', hid=str( hda.hid ) )
self.check_history_for_string( "<th>1.Chrom</th><th>2.Start</th><th>3.End</th>" )
self.delete_history( id=self.security.encode_id( history.id ) )
def test_0010_upload_file( self ):
"""Test uploading 4.bed.gz, manually setting the file format"""
self.check_history_for_string( 'Your history is empty' )
history = sa_session.query( galaxy.model.History ) \
.filter( and_( galaxy.model.History.table.c.deleted==False,
galaxy.model.History.table.c.user_id==admin_user.id ) ) \
.order_by( desc( galaxy.model.History.table.c.create_time ) ) \
.first()
self.upload_file( '4.bed.gz', dbkey='hg17', ftype='bed' )
hda4 = sa_session.query( galaxy.model.HistoryDatasetAssociation ) \
.order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ) \
.first()
assert hda4 is not None, "Problem retrieving hda4 from database"
self.verify_dataset_correctness( '4.bed', hid=str( hda4.hid ) )
hda = sa_session.query( galaxy.model.HistoryDatasetAssociation ) \
.order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ) \
.first()
assert hda is not None, "Problem retrieving hda from database"
self.verify_dataset_correctness( '4.bed', hid=str( hda.hid ) )
self.check_history_for_string( "<th>1.Chrom</th><th>2.Start</th><th>3.End</th>" )
self.delete_history( id=self.security.encode_id( history.id ) )
def test_0015_upload_file( self ):
"""Test uploading 1.scf, manually setting the file format"""
self.check_history_for_string( 'Your history is empty' )
history = sa_session.query( galaxy.model.History ) \
.filter( and_( galaxy.model.History.table.c.deleted==False,
galaxy.model.History.table.c.user_id==admin_user.id ) ) \
.order_by( desc( galaxy.model.History.table.c.create_time ) ) \
.first()
self.upload_file( '1.scf', ftype='scf' )
hda5 = sa_session.query( galaxy.model.HistoryDatasetAssociation ) \
.order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ) \
.first()
assert hda5 is not None, "Problem retrieving hda5 from database"
self.verify_dataset_correctness( '1.scf', hid=str( hda5.hid ) )
hda = sa_session.query( galaxy.model.HistoryDatasetAssociation ) \
.order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ) \
.first()
assert hda is not None, "Problem retrieving hda from database"
self.verify_dataset_correctness( '1.scf', hid=str( hda.hid ) )
self.check_history_for_string( "Binary scf sequence file</pre>" )
self.delete_history( id=self.security.encode_id( history.id ) )
def test_0020_upload_file( self ):
"""Test uploading 1.scf, NOT setting the file format"""
self.check_history_for_string( 'Your history is empty' )
history = sa_session.query( galaxy.model.History ) \
.filter( and_( galaxy.model.History.table.c.deleted==False,
galaxy.model.History.table.c.user_id==admin_user.id ) ) \
.order_by( desc( galaxy.model.History.table.c.create_time ) ) \
.first()
self.upload_file( '1.scf' )
hda = sa_session.query( galaxy.model.HistoryDatasetAssociation ) \
.order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ) \
.first()
assert hda is not None, "Problem retrieving hda from database"
self.check_history_for_string( "File Format' to 'Scf' when uploading scf files" )
self.delete_history( id=self.security.encode_id( history.id ) )
def test_0025_upload_file( self ):
"""Test uploading 1.scf.zip, manually setting the file format"""
self.check_history_for_string( 'Your history is empty' )
history = sa_session.query( galaxy.model.History ) \
.filter( and_( galaxy.model.History.table.c.deleted==False,
galaxy.model.History.table.c.user_id==admin_user.id ) ) \
.order_by( desc( galaxy.model.History.table.c.create_time ) ) \
.first()
self.upload_file( '1.scf.zip', ftype='binseq.zip' )
hda6 = sa_session.query( galaxy.model.HistoryDatasetAssociation ) \
.order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ) \
.first()
assert hda6 is not None, "Problem retrieving hda6 from database"
self.verify_dataset_correctness( '1.scf.zip', hid=str( hda6.hid ) )
self.delete_history( id=self.security.encode_id( history1.id ) )
def test_005_url_paste( self ):
hda = sa_session.query( galaxy.model.HistoryDatasetAssociation ) \
.order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ) \
.first()
assert hda is not None, "Problem retrieving hda from database"
self.verify_dataset_correctness( '1.scf.zip', hid=str( hda.hid ) )
self.check_history_for_string( "Archive of 1 binary sequence files</pre>" )
self.delete_history( id=self.security.encode_id( history.id ) )
def test_0030_upload_file( self ):
"""Test uploading 1.scf.zip, NOT setting the file format"""
self.check_history_for_string( 'Your history is empty' )
history = sa_session.query( galaxy.model.History ) \
.filter( and_( galaxy.model.History.table.c.deleted==False,
galaxy.model.History.table.c.user_id==admin_user.id ) ) \
.order_by( desc( galaxy.model.History.table.c.create_time ) ) \
.first()
self.upload_file( '1.scf.zip' )
hda = sa_session.query( galaxy.model.HistoryDatasetAssociation ) \
.order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ) \
.first()
assert hda is not None, "Problem retrieving hda from database"
self.check_history_for_string( "'File Format' for archive consisting of binary files - use 'Binseq.zip'" )
self.delete_history( id=self.security.encode_id( history.id ) )
def test_0035_upload_file( self ):
"""Test uploading 1.sam NOT setting the file format"""
self.check_history_for_string( 'Your history is empty' )
history = sa_session.query( galaxy.model.History ) \
.filter( and_( galaxy.model.History.table.c.deleted==False,
galaxy.model.History.table.c.user_id==admin_user.id ) ) \
.order_by( desc( galaxy.model.History.table.c.create_time ) ) \
.first()
self.upload_file( '1.sam' )
hda = sa_session.query( galaxy.model.HistoryDatasetAssociation ) \
.order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ) \
.first()
assert hda is not None, "Problem retrieving hda from database"
self.verify_dataset_correctness( '1.sam', hid=str( hda.hid ) )
self.check_history_for_string( "<th>1.QNAME</th><th>2.FLAG</th><th>3.RNAME</th><th>4.POS</th>" )
self.delete_history( id=self.security.encode_id( history.id ) )
def test_0040_upload_file( self ):
"""Test uploading 1.sff, NOT setting the file format"""
self.check_history_for_string( 'Your history is empty' )
history = sa_session.query( galaxy.model.History ) \
.filter( and_( galaxy.model.History.table.c.deleted==False,
galaxy.model.History.table.c.user_id==admin_user.id ) ) \
.order_by( desc( galaxy.model.History.table.c.create_time ) ) \
.first()
self.upload_file( '1.sff' )
hda = sa_session.query( galaxy.model.HistoryDatasetAssociation ) \
.order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ) \
.first()
assert hda is not None, "Problem retrieving hda from database"
self.verify_dataset_correctness( '1.sff', hid=str( hda.hid ) )
self.check_history_for_string( 'format: <span class="sff">sff' )
self.delete_history( id=self.security.encode_id( history.id ) )
def test_0045_upload_file( self ):
"""Test uploading 454Score.pdf, NOT setting the file format"""
self.check_history_for_string( 'Your history is empty' )
history = sa_session.query( galaxy.model.History ) \
.filter( and_( galaxy.model.History.table.c.deleted==False,
galaxy.model.History.table.c.user_id==admin_user.id ) ) \
.order_by( desc( galaxy.model.History.table.c.create_time ) ) \
.first()
self.upload_file( '454Score.pdf' )
hda = sa_session.query( galaxy.model.HistoryDatasetAssociation ) \
.order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ) \
.first()
assert hda is not None, "Problem retrieving hda from database"
self.check_history_for_string( "The uploaded file contains inappropriate content" )
self.delete_history( id=self.security.encode_id( history.id ) )
def test_0050_upload_file( self ):
"""Test uploading 454Score.png, NOT setting the file format"""
self.check_history_for_string( 'Your history is empty' )
history = sa_session.query( galaxy.model.History ) \
.filter( and_( galaxy.model.History.table.c.deleted==False,
galaxy.model.History.table.c.user_id==admin_user.id ) ) \
.order_by( desc( galaxy.model.History.table.c.create_time ) ) \
.first()
self.upload_file( '454Score.png' )
hda = sa_session.query( galaxy.model.HistoryDatasetAssociation ) \
.order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ) \
.first()
assert hda is not None, "Problem retrieving hda from database"
self.check_history_for_string( "The uploaded file contains inappropriate content" )
def test_0055_upload_file( self ):
"""Test uploading lped composite datatype file, manually setting the file format"""
# Logged in as admin_user
self.check_history_for_string( 'Your history is empty' )
history = sa_session.query( galaxy.model.History ) \
.filter( and_( galaxy.model.History.table.c.deleted==False,
galaxy.model.History.table.c.user_id==admin_user.id ) ) \
.order_by( desc( galaxy.model.History.table.c.create_time ) ) \
.first()
# lped data types include a ped_file and a map_file ( which is binary )
self.upload_composite_datatype_file( 'lped', ped_file='tinywga.ped', map_file='tinywga.map', base_name='rgenetics' )
# Get the latest hid for testing
hda = sa_session.query( galaxy.model.HistoryDatasetAssociation ) \
.order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ) \
.first()
assert hda is not None, "Problem retrieving hda from database"
# We'll test against the resulting ped file and map file for correctness
self.verify_composite_datatype_file_content( 'rgenetics.ped', str( hda.id ) )
self.verify_composite_datatype_file_content( 'rgenetics.map', str( hda.id ) )
self.check_history_for_string( "Uploaded Composite Dataset (lped)" )
self.delete_history( id=self.security.encode_id( history.id ) )
def test_0060_upload_file( self ):
"""Test uploading pbed composite datatype file, manually setting the file format"""
# Logged in as admin_user
self.check_history_for_string( 'Your history is empty' )
history = sa_session.query( galaxy.model.History ) \
.filter( and_( galaxy.model.History.table.c.deleted==False,
galaxy.model.History.table.c.user_id==admin_user.id ) ) \
.order_by( desc( galaxy.model.History.table.c.create_time ) ) \
.first()
# pbed data types include a bim_file, a bed_file and a fam_file
self.upload_composite_datatype_file( 'pbed', bim_file='tinywga.bim', bed_file='tinywga.bed', fam_file='tinywga.fam', base_name='rgenetics' )
# Get the latest hid for testing
hda = sa_session.query( galaxy.model.HistoryDatasetAssociation ) \
.order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ) \
.first()
assert hda is not None, "Problem retrieving hda from database"
# We'll test against the resulting ped file and map file for correctness
self.verify_composite_datatype_file_content( 'rgenetics.bim', str( hda.id ) )
self.verify_composite_datatype_file_content( 'rgenetics.bed', str( hda.id ) )
self.verify_composite_datatype_file_content( 'rgenetics.fam', str( hda.id ) )
self.check_history_for_string( "Uploaded Composite Dataset (pbed)" )
self.delete_history( id=self.security.encode_id( history.id ) )
def test_0065_upload_file( self ):
"""Test uploading asian_chars_1.txt, NOT setting the file format"""
# Logged in as admin_user
self.check_history_for_string( 'Your history is empty' )
history = sa_session.query( galaxy.model.History ) \
.filter( and_( galaxy.model.History.table.c.deleted==False,
galaxy.model.History.table.c.user_id==admin_user.id ) ) \
.order_by( desc( galaxy.model.History.table.c.create_time ) ) \
.first()
self.upload_file( 'asian_chars_1.txt' )
hda = sa_session.query( galaxy.model.HistoryDatasetAssociation ) \
.order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ) \
.first()
assert hda is not None, "Problem retrieving hda from database"
self.verify_dataset_correctness( 'asian_chars_1.txt', hid=str( hda.hid ) )
self.check_history_for_string( 'uploaded multi-byte char file' )
self.delete_history( id=self.security.encode_id( history.id ) )
def test_0070_upload_file( self ):
"""Test uploading 2gen.fastq, NOT setting the file format"""
# Logged in as admin_user
self.check_history_for_string( 'Your history is empty' )
history = sa_session.query( galaxy.model.History ) \
.filter( and_( galaxy.model.History.table.c.deleted==False,
galaxy.model.History.table.c.user_id==admin_user.id ) ) \
.order_by( desc( galaxy.model.History.table.c.create_time ) ) \
.first()
self.upload_file( '2gen.fastq' )
hda = sa_session.query( galaxy.model.HistoryDatasetAssociation ) \
.order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ) \
.first()
assert hda is not None, "Problem retrieving hda from database"
self.verify_dataset_correctness( '2gen.fastq', hid=str( hda.hid ) )
self.check_history_for_string( '2gen.fastq format: <span class="fastq">fastq</span>, database: \? Info: uploaded fastq file' )
self.delete_history( id=self.security.encode_id( history.id ) )
def test_0075_upload_file( self ):
"""Test uploading 1.wig, NOT setting the file format"""
# Logged in as admin_user
self.check_history_for_string( 'Your history is empty' )
history = sa_session.query( galaxy.model.History ) \
.filter( and_( galaxy.model.History.table.c.deleted==False,
galaxy.model.History.table.c.user_id==admin_user.id ) ) \
.order_by( desc( galaxy.model.History.table.c.create_time ) ) \
.first()
self.upload_file( '1.wig' )
hda = sa_session.query( galaxy.model.HistoryDatasetAssociation ) \
.order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ) \
.first()
assert hda is not None, "Problem retrieving hda from database"
self.verify_dataset_correctness( '1.wig', hid=str( hda.hid ) )
self.check_history_for_string( '1.wig format: <span class="wig">wig</span>, database: \? Info: uploaded file' )
self.check_metadata_for_string( 'value="1.wig" value="\?"' )
self.check_metadata_for_string( 'Change data type selected value="wig" selected="yes"' )
self.delete_history( id=self.security.encode_id( history.id ) )
def test_0080_upload_file( self ):
"""Test uploading 1.tabular, NOT setting the file format"""
# Logged in as admin_user
self.check_history_for_string( 'Your history is empty' )
history = sa_session.query( galaxy.model.History ) \
.filter( and_( galaxy.model.History.table.c.deleted==False,
galaxy.model.History.table.c.user_id==admin_user.id ) ) \
.order_by( desc( galaxy.model.History.table.c.create_time ) ) \
.first()
self.upload_file( '1.tabular' )
hda = sa_session.query( galaxy.model.HistoryDatasetAssociation ) \
.order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ) \
.first()
assert hda is not None, "Problem retrieving hda from database"
self.verify_dataset_correctness( '1.tabular', hid=str( hda.hid ) )
self.check_history_for_string( '1.tabular format: <span class="tabular">tabular</span>, database: \? Info: uploaded file' )
self.check_metadata_for_string( 'value="1.tabular" value="\?"' )
self.check_metadata_for_string( 'Change data type selected value="tabular" selected="yes"' )
self.delete_history( id=self.security.encode_id( history.id ) )
def test_0085_upload_file( self ):
"""Test uploading qualscores.qualsolid, NOT setting the file format"""
# Logged in as admin_user
self.check_history_for_string( 'Your history is empty' )
history = sa_session.query( galaxy.model.History ) \
.filter( and_( galaxy.model.History.table.c.deleted==False,
galaxy.model.History.table.c.user_id==admin_user.id ) ) \
.order_by( desc( galaxy.model.History.table.c.create_time ) ) \
.first()
self.upload_file( 'qualscores.qualsolid' )
hda = sa_session.query( galaxy.model.HistoryDatasetAssociation ) \
.order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ) \
.first()
assert hda is not None, "Problem retrieving hda from database"
self.verify_dataset_correctness( 'qualscores.qualsolid', hid=str( hda.hid ) )
self.check_history_for_string( '2.5 Kb, format: <span class="qualsolid">qualsolid</span>, database: \? Info: uploaded file' )
self.check_metadata_for_string( 'Change data type value="qualsolid" selected="yes">qualsolid' )
self.delete_history( id=self.security.encode_id( history.id ) )
def test_0090_upload_file( self ):
"""Test uploading qualscores.qual454, NOT setting the file format"""
# Logged in as admin_user
self.check_history_for_string( 'Your history is empty' )
history = sa_session.query( galaxy.model.History ) \
.filter( and_( galaxy.model.History.table.c.deleted==False,
galaxy.model.History.table.c.user_id==admin_user.id ) ) \
.order_by( desc( galaxy.model.History.table.c.create_time ) ) \
.first()
self.upload_file( 'qualscores.qual454' )
hda = sa_session.query( galaxy.model.HistoryDatasetAssociation ) \
.order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ) \
.first()
assert hda is not None, "Problem retrieving hda from database"
self.verify_dataset_correctness( 'qualscores.qual454', hid=str( hda.hid ) )
self.check_history_for_string( '5.6 Kb, format: <span class="qual454">qual454</span>, database: \?' )
self.check_metadata_for_string( 'Change data type value="qual454" selected="yes">qual454' )
self.delete_history( id=self.security.encode_id( history.id ) )
def test_0095_upload_file( self ):
"""Test uploading 3.maf, NOT setting the file format"""
# Logged in as admin_user
self.check_history_for_string( 'Your history is empty' )
history = sa_session.query( galaxy.model.History ) \
.filter( and_( galaxy.model.History.table.c.deleted==False,
galaxy.model.History.table.c.user_id==admin_user.id ) ) \
.order_by( desc( galaxy.model.History.table.c.create_time ) ) \
.first()
self.upload_file( '3.maf' )
hda = sa_session.query( galaxy.model.HistoryDatasetAssociation ) \
.order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ) \
.first()
assert hda is not None, "Problem retrieving hda from database"
self.verify_dataset_correctness( '3.maf', hid=str( hda.hid ) )
self.check_history_for_string( '3.maf format: <span class="maf">maf</span>, database: \? Info: uploaded file' )
self.check_metadata_for_string( 'value="3.maf" value="\?"' )
self.check_metadata_for_string( 'Convert to new format <option value="interval">Convert MAF to Genomic Intervals <option value="fasta">Convert MAF to Fasta' )
self.check_metadata_for_string( 'Change data type selected value="maf" selected="yes"' )
self.delete_history( id=self.security.encode_id( history.id ) )
def test_0100_upload_file( self ):
"""Test uploading 1.lav, NOT setting the file format"""
# Logged in as admin_user
self.check_history_for_string( 'Your history is empty' )
history = sa_session.query( galaxy.model.History ) \
.filter( and_( galaxy.model.History.table.c.deleted==False,
galaxy.model.History.table.c.user_id==admin_user.id ) ) \
.order_by( desc( galaxy.model.History.table.c.create_time ) ) \
.first()
self.upload_file( '1.lav' )
hda = sa_session.query( galaxy.model.HistoryDatasetAssociation ) \
.order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ) \
.first()
assert hda is not None, "Problem retrieving hda from database"
self.verify_dataset_correctness( '1.lav', hid=str( hda.hid ) )
self.check_history_for_string( '1.lav format: <span class="lav">lav</span>, database: \? Info: uploaded file' )
self.check_metadata_for_string( 'value="1.lav" value="\?"' )
self.check_metadata_for_string( 'Change data type selected value="lav" selected="yes"' )
self.delete_history( id=self.security.encode_id( history.id ) )
def test_0105_upload_file( self ):
"""Test uploading 1.interval, NOT setting the file format"""
# Logged in as admin_user
self.check_history_for_string( 'Your history is empty' )
history = sa_session.query( galaxy.model.History ) \
.filter( and_( galaxy.model.History.table.c.deleted==False,
galaxy.model.History.table.c.user_id==admin_user.id ) ) \
.order_by( desc( galaxy.model.History.table.c.create_time ) ) \
.first()
self.upload_file( '1.interval' )
hda = sa_session.query( galaxy.model.HistoryDatasetAssociation ) \
.order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ) \
.first()
assert hda is not None, "Problem retrieving hda from database"
self.verify_dataset_correctness( '1.interval', hid=str( hda.hid ) )
self.check_history_for_string( '1.interval format: <span class="interval">interval</span>, database: \? Info: uploaded file' )
self.check_metadata_for_string( 'value="1.interval" value="\?"' )
self.check_metadata_for_string( 'Chrom column: <option value="1" selected> Start column: <option value="2" selected>' )
self.check_metadata_for_string( 'End column: <option value="3" selected> Strand column <option value="6" selected>' )
self.check_metadata_for_string( 'Convert to new format <option value="bed">Convert Genomic Intervals To BED' )
self.check_metadata_for_string( 'Change data type selected value="interval" selected="yes"' )
self.delete_history( id=self.security.encode_id( history.id ) )
def test_0110_upload_file( self ):
"""Test uploading 5.gff3, NOT setting the file format"""
# Logged in as admin_user
self.check_history_for_string( 'Your history is empty' )
history = sa_session.query( galaxy.model.History ) \
.filter( and_( galaxy.model.History.table.c.deleted==False,
galaxy.model.History.table.c.user_id==admin_user.id ) ) \
.order_by( desc( galaxy.model.History.table.c.create_time ) ) \
.first()
self.upload_file( '5.gff3' )
hda = sa_session.query( galaxy.model.HistoryDatasetAssociation ) \
.order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ) \
.first()
assert hda is not None, "Problem retrieving hda from database"
self.verify_dataset_correctness( '5.gff3', hid=str( hda.hid ) )
self.check_history_for_string( '5.gff3 format: <span class="gff3">gff3</span>, database: \? Info: uploaded file' )
self.check_metadata_for_string( 'value="5.gff3" value="\?"' )
self.check_metadata_for_string( 'Convert to new format <option value="bed">Convert GFF to BED' )
self.check_metadata_for_string( 'Change data type selected value="gff3" selected="yes"' )
self.delete_history( id=self.security.encode_id( history.id ) )
def test_0115_upload_file( self ):
"""Test uploading html_file.txt, NOT setting the file format"""
# Logged in as admin_user
self.check_history_for_string( 'Your history is empty' )
history = sa_session.query( galaxy.model.History ) \
.filter( and_( galaxy.model.History.table.c.deleted==False,
galaxy.model.History.table.c.user_id==admin_user.id ) ) \
.order_by( desc( galaxy.model.History.table.c.create_time ) ) \
.first()
self.upload_file( 'html_file.txt' )
hda = sa_session.query( galaxy.model.HistoryDatasetAssociation ) \
.order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ) \
.first()
assert hda is not None, "Problem retrieving hda from database"
self.check_history_for_string( 'The uploaded file contains inappropriate content' )
self.delete_history( id=self.security.encode_id( history.id ) )
def test_0120_upload_file( self ):
"""Test uploading 5.gff, NOT setting the file format"""
# Logged in as admin_user
self.check_history_for_string( 'Your history is empty' )
history = sa_session.query( galaxy.model.History ) \
.filter( and_( galaxy.model.History.table.c.deleted==False,
galaxy.model.History.table.c.user_id==admin_user.id ) ) \
.order_by( desc( galaxy.model.History.table.c.create_time ) ) \
.first()
self.upload_file( '5.gff' )
hda = sa_session.query( galaxy.model.HistoryDatasetAssociation ) \
.order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ) \
.first()
assert hda is not None, "Problem retrieving hda from database"
self.verify_dataset_correctness( '5.gff', hid=str( hda.hid ) )
self.check_history_for_string( '5.gff format: <span class="gff">gff</span>, database: \? Info: uploaded file' )
self.check_metadata_for_string( 'value="5.gff" value="\?"' )
self.check_metadata_for_string( 'Convert to new format <option value="bed">Convert GFF to BED' )
self.check_metadata_for_string( 'Change data type selected value="gff" selected="yes"' )
self.delete_history( id=self.security.encode_id( history.id ) )
def test_0125_upload_file( self ):
"""Test uploading 1.fasta, NOT setting the file format"""
# Logged in as admin_user
self.check_history_for_string( 'Your history is empty' )
history = sa_session.query( galaxy.model.History ) \
.filter( and_( galaxy.model.History.table.c.deleted==False,
galaxy.model.History.table.c.user_id==admin_user.id ) ) \
.order_by( desc( galaxy.model.History.table.c.create_time ) ) \
.first()
self.upload_file( '1.fasta' )
hda = sa_session.query( galaxy.model.HistoryDatasetAssociation ) \
.order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ) \
.first()
assert hda is not None, "Problem retrieving hda from database"
self.verify_dataset_correctness( '1.fasta', hid=str( hda.hid ) )
self.check_history_for_string( '1.fasta format: <span class="fasta">fasta</span>, database: \? Info: uploaded file' )
self.check_metadata_for_string( 'value="1.fasta" value="\?" Change data type selected value="fasta" selected="yes"' )
self.delete_history( id=self.security.encode_id( history.id ) )
def test_0130_upload_file( self ):
"""Test uploading 1.customtrack, NOT setting the file format"""
# Logged in as admin_user
self.check_history_for_string( 'Your history is empty' )
history = sa_session.query( galaxy.model.History ) \
.filter( and_( galaxy.model.History.table.c.deleted==False,
galaxy.model.History.table.c.user_id==admin_user.id ) ) \
.order_by( desc( galaxy.model.History.table.c.create_time ) ) \
.first()
self.upload_file( '1.customtrack' )
hda = sa_session.query( galaxy.model.HistoryDatasetAssociation ) \
.order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ) \
.first()
assert hda is not None, "Problem retrieving hda from database"
self.verify_dataset_correctness( '1.customtrack', hid=str( hda.hid ) )
self.check_history_for_string( '1.customtrack format: <span class="customtrack">customtrack</span>, database: \? Info: uploaded file' )
self.check_metadata_for_string( 'value="1.customtrack" value="\?" Change data type selected value="customtrack" selected="yes"' )
self.delete_history( id=self.security.encode_id( history.id ) )
def test_0135_upload_file( self ):
"""Test uploading shrimp_cs_test1.csfasta, NOT setting the file format"""
# Logged in as admin_user
self.check_history_for_string( 'Your history is empty' )
history = sa_session.query( galaxy.model.History ) \
.filter( and_( galaxy.model.History.table.c.deleted==False,
galaxy.model.History.table.c.user_id==admin_user.id ) ) \
.order_by( desc( galaxy.model.History.table.c.create_time ) ) \
.first()
self.upload_file( 'shrimp_cs_test1.csfasta' )
hda = sa_session.query( galaxy.model.HistoryDatasetAssociation ) \
.order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ) \
.first()
assert hda is not None, "Problem retrieving hda from database"
self.verify_dataset_correctness( 'shrimp_cs_test1.csfasta', hid=str( hda.hid ) )
self.check_history_for_string( '162.6 Kb, format: <span class="csfasta">csfasta</span>, <td>&gt;2_14_26_F3,-1282216.0</td>' )
self.check_metadata_for_string( 'value="shrimp_cs_test1.csfasta" value="\?" Change data type value="csfasta" selected="yes"' )
self.delete_history( id=self.security.encode_id( history.id ) )
def test_0140_upload_file( self ):
"""Test uploading megablast_xml_parser_test1.gz, NOT setting the file format"""
# Logged in as admin_user
self.check_history_for_string( 'Your history is empty' )
history = sa_session.query( galaxy.model.History ) \
.filter( and_( galaxy.model.History.table.c.deleted==False,
galaxy.model.History.table.c.user_id==admin_user.id ) ) \
.order_by( desc( galaxy.model.History.table.c.create_time ) ) \
.first()
self.upload_file( 'megablast_xml_parser_test1.gz' )
hda = sa_session.query( galaxy.model.HistoryDatasetAssociation ) \
.order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ) \
.first()
assert hda is not None, "Problem retrieving hda from database"
self.check_history_for_string( 'NCBI Blast XML data format: <span class="blastxml">blastxml</span>' )
self.delete_history( id=self.security.encode_id( history.id ) )
def test_0145_upload_file( self ):
"""Test uploading 1.axt, NOT setting the file format"""
# Logged in as admin_user
self.check_history_for_string( 'Your history is empty' )
history = sa_session.query( galaxy.model.History ) \
.filter( and_( galaxy.model.History.table.c.deleted==False,
galaxy.model.History.table.c.user_id==admin_user.id ) ) \
.order_by( desc( galaxy.model.History.table.c.create_time ) ) \
.first()
self.upload_file( '1.axt' )
hda = sa_session.query( galaxy.model.HistoryDatasetAssociation ) \
.order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ) \
.first()
assert hda is not None, "Problem retrieving hda from database"
self.verify_dataset_correctness( '1.axt', hid=str( hda.hid ) )
self.check_history_for_string( '1.axt format: <span class="axt">axt</span>, database: \? Info: uploaded file' )
self.check_metadata_for_string( 'value="1.axt" value="\?" Change data type selected value="axt" selected="yes"' )
self.delete_history( id=self.security.encode_id( history.id ) )
def test_0150_url_paste( self ):
"""Test url paste behavior"""
# Logged in as admin_user
# Deleting the current history should have created a new history
self.check_history_for_string( 'Your history is empty' )
history2 = sa_session.query( galaxy.model.History ) \
.filter( and_( galaxy.model.History.table.c.deleted==False,
galaxy.model.History.table.c.user_id==admin_user.id ) ) \
.order_by( desc( galaxy.model.History.table.c.create_time ) ) \
.first()
history = sa_session.query( galaxy.model.History ) \
.filter( and_( galaxy.model.History.table.c.deleted==False,
galaxy.model.History.table.c.user_id==admin_user.id ) ) \
.order_by( desc( galaxy.model.History.table.c.create_time ) ) \
.first()
self.upload_url_paste( 'hello world' )
self.check_history_for_string( 'Pasted Entry' )
self.check_history_for_string( 'hello world' )
self.upload_url_paste( u'hello world' )
self.check_history_for_string( 'Pasted Entry' )
self.check_history_for_string( 'hello world' )
self.delete_history( id=self.security.encode_id( history2.id ) )
def test_010_upload_lped_composite_datatype_files( self ):
"""Test uploading lped composite datatype files"""
# Logged in as admin_user
self.check_history_for_string( 'Your history is empty' )
history3 = sa_session.query( galaxy.model.History ) \
.filter( and_( galaxy.model.History.table.c.deleted==False,
galaxy.model.History.table.c.user_id==admin_user.id ) ) \
.order_by( desc( galaxy.model.History.table.c.create_time ) ) \
.first()
# lped data types include a ped_file and a map_file ( which is binary )
self.upload_composite_datatype_file( 'lped', ped_file='tinywga.ped', map_file='tinywga.map', base_name='rgenetics' )
# Get the latest hid for testing
hda1 = sa_session.query( galaxy.model.HistoryDatasetAssociation ) \
.order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ) \
.first()
assert hda1 is not None, "Problem retrieving hda1 from database"
# We'll test against the resulting ped file and map file for correctness
self.verify_composite_datatype_file_content( 'rgenetics.ped', str( hda1.id ) )
self.verify_composite_datatype_file_content( 'rgenetics.map', str( hda1.id ) )
self.delete_history( id=self.security.encode_id( history3.id ) )
def test_015_upload_pbed_composite_datatype_files( self ):
"""Test uploading pbed composite datatype files"""
# Logged in as admin_user
self.check_history_for_string( 'Your history is empty' )
history4 = sa_session.query( galaxy.model.History ) \
.filter( and_( galaxy.model.History.table.c.deleted==False,
galaxy.model.History.table.c.user_id==admin_user.id ) ) \
.order_by( desc( galaxy.model.History.table.c.create_time ) ) \
.first()
# pbed data types include a bim_file, a bed_file and a fam_file
self.upload_composite_datatype_file( 'pbed', bim_file='tinywga.bim', bed_file='tinywga.bed', fam_file='tinywga.fam', base_name='rgenetics' )
# Get the latest hid for testing
hda1 = sa_session.query( galaxy.model.HistoryDatasetAssociation ) \
.order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ) \
.first()
assert hda1 is not None, "Problem retrieving hda1 from database"
# We'll test against the resulting ped file and map file for correctness
self.verify_composite_datatype_file_content( 'rgenetics.bim', str( hda1.id ) )
self.verify_composite_datatype_file_content( 'rgenetics.bed', str( hda1.id ) )
self.verify_composite_datatype_file_content( 'rgenetics.fam', str( hda1.id ) )
self.delete_history( id=self.security.encode_id( history4.id ) )
def test_020_upload_multibyte_character_file( self ):
"""Test uploading multi-byte character file"""
# Logged in as admin_user
self.check_history_for_string( 'Your history is empty' )
history5 = sa_session.query( galaxy.model.History ) \
.filter( and_( galaxy.model.History.table.c.deleted==False,
galaxy.model.History.table.c.user_id==admin_user.id ) ) \
.order_by( desc( galaxy.model.History.table.c.create_time ) ) \
.first()
self.upload_file( 'asian_chars_1.txt' )
hda1 = sa_session.query( galaxy.model.HistoryDatasetAssociation ) \
.order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ) \
.first()
assert hda1 is not None, "Problem retrieving hda1 from database"
self.verify_dataset_correctness( 'asian_chars_1.txt', hid=str( hda1.hid ) )
self.check_history_for_string( 'uploaded multi-byte char file' )
self.delete_history( id=self.security.encode_id( history5.id ) )
self.delete_history( id=self.security.encode_id( history.id ) )
def test_9999_clean_up( self ):
self.logout()
test/functional/test_history_functions.py
+6
View File
@@ -603,6 +603,12 @@ class TestHistory( TwillTestCase ):
except:
pass
self.check_history_for_string( 'You do not have permission to view this dataset' )
# Admin users can view all datasets ( using the history/view feature ), so make sure 2.bed is accessible to the admin
self.logout()
self.login( email=admin_user.email )
self.view_history( str( hda_2_bed.history_id ), check_str='<td>NM_005997_cds_0_0_chr1_147962193_r</td>' )
self.logout()
self.login( email=regular_user3.email )
# Delete the clone so the next test will be valid
self.delete_history( id=self.security.encode_id( history5_clone4.id ) )
def test_065_sharing_private_history_by_choosing_to_not_share( self ):
test/functional/test_sniffing_and_metadata_settings.py
-262
View File
@@ -1,262 +0,0 @@
import galaxy.model
from galaxy.model.orm import *
from galaxy.model.mapping import context as sa_session
from base.twilltestcase import TwillTestCase
class SniffingAndMetaDataSettings( TwillTestCase ):
def test_000_axt_datatype( self ):
"""Testing correctly sniffing axt data type upon upload"""
self.logout()
self.login( email='test@bx.psu.edu' )
global admin_user
admin_user = sa_session.query( galaxy.model.User ).filter( galaxy.model.User.table.c.email=='test@bx.psu.edu' ).one()
self.new_history( name='history1' )
global history1
history1 = sa_session.query( galaxy.model.History ) \
.filter( and_( galaxy.model.History.table.c.deleted==False,
galaxy.model.History.table.c.user_id==admin_user.id ) ) \
.order_by( desc( galaxy.model.History.table.c.create_time ) ) \
.first()
assert history1 is not None, "Problem retrieving history1 from database"
self.upload_file( '1.axt' )
self.verify_dataset_correctness( '1.axt' )
self.check_history_for_string( '1.axt format: <span class="axt">axt</span>, database: \? Info: uploaded file' )
self.check_metadata_for_string( 'value="1.axt" value="\?" Change data type selected value="axt" selected="yes"' )
latest_hda = sa_session.query( galaxy.model.HistoryDatasetAssociation ) \
.order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ) \
.first()
assert latest_hda is not None, "Problem retrieving axt hda from the database"
if not latest_hda.name == '1.axt' and not latest_hda.extension == 'axt':
raise AssertionError, "axt data type was not correctly sniffed."
def test_005_bed_datatype( self ):
"""Testing correctly sniffing bed data type upon upload"""
self.upload_file( '1.bed' )
self.verify_dataset_correctness( '1.bed' )
self.check_history_for_string( '1.bed format: <span class="bed">bed</span>, database: \? Info: uploaded file')
self.check_metadata_for_string( 'value="1.bed" value="\?"' )
self.check_metadata_for_string( 'Chrom column: <option value="1" selected> Start column: <option value="2" selected>' )
self.check_metadata_for_string( 'End column: <option value="3" selected> Strand column <option value="6" selected>' )
self.check_metadata_for_string( 'Convert to new format value="bed">Convert Genomic Intervals To BED <option value="gff">Convert BED to GFF' )
self.check_metadata_for_string( 'Change data type selected value="bed" selected="yes"' )
latest_hda = sa_session.query( galaxy.model.HistoryDatasetAssociation ) \
.order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ) \
.first()
assert latest_hda is not None, "Problem retrieving bed hda from the database"
if not latest_hda.name == '1.bed' and not latest_hda.extension == 'bed':
raise AssertionError, "bed data type was not correctly sniffed."
def test_010_blastxml_datatype( self ):
"""Testing correctly sniffing blastxml data type upon upload"""
self.upload_file( 'megablast_xml_parser_test1.gz' )
self.check_history_for_string( 'NCBI Blast XML data format: <span class="blastxml">blastxml</span>' )
latest_hda = sa_session.query( galaxy.model.HistoryDatasetAssociation ) \
.order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ) \
.first()
assert latest_hda is not None, "Problem retrieving blastxml hda from the database"
if not latest_hda.name == 'megablast_xml_parser_test1' and not latest_hda.extension == 'blastxml':
raise AssertionError, "blastxml data type was not correctly sniffed."
def test_015_csfasta_datatype( self ):
"""Testing correctly sniffing csfasta data type upon upload"""
self.upload_file( 'shrimp_cs_test1.csfasta' )
self.verify_dataset_correctness( 'shrimp_cs_test1.csfasta' )
self.check_history_for_string( '162.6 Kb, format: <span class="csfasta">csfasta</span>, <td>&gt;2_14_26_F3,-1282216.0</td>' )
self.check_metadata_for_string( 'value="shrimp_cs_test1.csfasta" value="\?" Change data type value="csfasta" selected="yes"' )
latest_hda = sa_session.query( galaxy.model.HistoryDatasetAssociation ) \
.order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ) \
.first()
assert latest_hda is not None, "Problem retrieving csfasta hda from the database"
if not latest_hda.name == 'shrimp_cs_test1.csfasta' and not latest_hda.extension == 'csfasta':
raise AssertionError, "csfasta data type was not correctly sniffed."
def test_020_customtrack_datatype( self ):
"""Testing correctly sniffing customtrack data type upon upload"""
self.upload_file( '1.customtrack' )
self.verify_dataset_correctness( '1.customtrack' )
self.check_history_for_string( '1.customtrack format: <span class="customtrack">customtrack</span>, database: \? Info: uploaded file' )
self.check_metadata_for_string( 'value="1.customtrack" value="\?" Change data type selected value="customtrack" selected="yes"' )
latest_hda = sa_session.query( galaxy.model.HistoryDatasetAssociation ) \
.order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ) \
.first()
assert latest_hda is not None, "Problem retrieving customtrack hda from the database"
if not latest_hda.name == '1.customtrack' and not latest_hda.extension == 'customtrack':
raise AssertionError, "customtrack data type was not correctly sniffed."
def test_025_fasta_datatype( self ):
"""Testing correctly sniffing fasta data type upon upload"""
self.upload_file( '1.fasta' )
self.verify_dataset_correctness( '1.fasta' )
self.check_history_for_string( '1.fasta format: <span class="fasta">fasta</span>, database: \? Info: uploaded file' )
self.check_metadata_for_string( 'value="1.fasta" value="\?" Change data type selected value="fasta" selected="yes"' )
latest_hda = sa_session.query( galaxy.model.HistoryDatasetAssociation ) \
.order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ) \
.first()
assert latest_hda is not None, "Problem retrieving fasta hda from the database"
if not latest_hda.name == '1.fasta' and not latest_hda.extension == 'fasta':
raise AssertionError, "fasta data type was not correctly sniffed."
def test_035_gff_datatype( self ):
"""Testing correctly sniffing gff data type upon upload"""
self.upload_file( '5.gff' )
self.verify_dataset_correctness( '5.gff' )
self.check_history_for_string( '5.gff format: <span class="gff">gff</span>, database: \? Info: uploaded file' )
self.check_metadata_for_string( 'value="5.gff" value="\?"' )
self.check_metadata_for_string( 'Convert to new format <option value="bed">Convert GFF to BED' )
self.check_metadata_for_string( 'Change data type selected value="gff" selected="yes"' )
latest_hda = sa_session.query( galaxy.model.HistoryDatasetAssociation ) \
.order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ) \
.first()
assert latest_hda is not None, "Problem retrieving gff hda from the database"
if not latest_hda.name == '5.gff' and not latest_hda.extension == 'gff':
raise AssertionError, "gff data type was not correctly sniffed."
def test_040_gff3_datatype( self ):
"""Testing correctly sniffing gff3 data type upon upload"""
self.upload_file( '5.gff3' )
self.verify_dataset_correctness( '5.gff3' )
self.check_history_for_string( '5.gff3 format: <span class="gff3">gff3</span>, database: \? Info: uploaded file' )
self.check_metadata_for_string( 'value="5.gff3" value="\?"' )
self.check_metadata_for_string( 'Convert to new format <option value="bed">Convert GFF to BED' )
self.check_metadata_for_string( 'Change data type selected value="gff3" selected="yes"' )
latest_hda = sa_session.query( galaxy.model.HistoryDatasetAssociation ) \
.order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ) \
.first()
assert latest_hda is not None, "Problem retrieving gff3 hda from the database"
if not latest_hda.name == '5.gff3' and not latest_hda.extension == 'gff3':
raise AssertionError, "gff3 data type was not correctly sniffed."
# TODO: the following test generates a data.hid == None, breaking this and all following tests
# I am not currently able to track down why, and uploading inappropriate files outside of the
# functional test framework seems to generate valid hids, so this needs to be tracked down and fixed
# ASAP, un-commenting this test.
#def test_045_html_datatype( self ):
#"""Testing correctly sniffing html data type upon upload"""
#self.upload_file( 'html_file.txt' )
#self.check_history_for_string( 'An error occurred running this job: No data: you attempted to upload an inappropriate file.' )
#latest_hda = galaxy.model.HistoryDatasetAssociation.query() \
# .order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ).first()
#assert latest_hda is not None, "Problem retrieving html hda from the database"
#if not latest_hda.name == 'html_file.txt' and not latest_hda.extension == 'data':
# raise AssertionError, "html data type was not correctly sniffed."
def test_050_interval_datatype( self ):
"""Testing correctly sniffing interval data type upon upload"""
self.upload_file( '1.interval' )
self.verify_dataset_correctness( '1.interval' )
self.check_history_for_string( '1.interval format: <span class="interval">interval</span>, database: \? Info: uploaded file' )
self.check_metadata_for_string( 'value="1.interval" value="\?"' )
self.check_metadata_for_string( 'Chrom column: <option value="1" selected> Start column: <option value="2" selected>' )
self.check_metadata_for_string( 'End column: <option value="3" selected> Strand column <option value="6" selected>' )
self.check_metadata_for_string( 'Convert to new format <option value="bed">Convert Genomic Intervals To BED' )
self.check_metadata_for_string( 'Change data type selected value="interval" selected="yes"' )
latest_hda = sa_session.query( galaxy.model.HistoryDatasetAssociation ) \
.order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ) \
.first()
assert latest_hda is not None, "Problem retrieving interval hda from the database"
if not latest_hda.name == '1.interval' and not latest_hda.extension == 'interval':
raise AssertionError, "interval data type was not correctly sniffed."
def test_055_lav_datatype( self ):
"""Testing correctly sniffing lav data type upon upload"""
self.upload_file( '1.lav' )
self.verify_dataset_correctness( '1.lav' )
self.check_history_for_string( '1.lav format: <span class="lav">lav</span>, database: \? Info: uploaded file' )
self.check_metadata_for_string( 'value="1.lav" value="\?"' )
self.check_metadata_for_string( 'Change data type selected value="lav" selected="yes"' )
latest_hda = sa_session.query( galaxy.model.HistoryDatasetAssociation ) \
.order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ) \
.first()
assert latest_hda is not None, "Problem retrieving lav hda from the database"
if not latest_hda.name == '1.lav' and not latest_hda.extension == 'lav':
raise AssertionError, "lav data type was not correctly sniffed."
def test_060_maf_datatype( self ):
"""Testing correctly sniffing maf data type upon upload"""
self.upload_file( '3.maf' )
self.verify_dataset_correctness( '3.maf' )
self.check_history_for_string( '3.maf format: <span class="maf">maf</span>, database: \? Info: uploaded file' )
self.check_metadata_for_string( 'value="3.maf" value="\?"' )
self.check_metadata_for_string( 'Convert to new format <option value="interval">Convert MAF to Genomic Intervals <option value="fasta">Convert MAF to Fasta' )
self.check_metadata_for_string( 'Change data type selected value="maf" selected="yes"' )
latest_hda = sa_session.query( galaxy.model.HistoryDatasetAssociation ) \
.order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ) \
.first()
assert latest_hda is not None, "Problem retrieving maf hda from the database"
if not latest_hda.name == '3.maf' and not latest_hda.extension == 'maf':
raise AssertionError, "maf data type was not correctly sniffed."
def test_065_qual454_datatype( self ):
"""Testing correctly sniffing qual454 data type upon upload"""
self.upload_file( 'qualscores.qual454' )
self.verify_dataset_correctness( 'qualscores.qual454' )
self.check_history_for_string( '5.6 Kb, format: <span class="qual454">qual454</span>, database: \?' )
self.check_metadata_for_string( 'Change data type value="qual454" selected="yes">qual454' )
latest_hda = sa_session.query( galaxy.model.HistoryDatasetAssociation ) \
.order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ) \
.first()
assert latest_hda is not None, "Problem retrieving qual454 hda from the database"
if not latest_hda.name == 'qualscores.qual454' and not latest_hda.extension == 'qual454':
raise AssertionError, "qual454 data type was not correctly sniffed."
def test_070_qualsolid_datatype( self ):
"""Testing correctly sniffing qualsolid data type upon upload"""
self.upload_file( 'qualscores.qualsolid' )
self.verify_dataset_correctness('qualscores.qualsolid' )
self.check_history_for_string('2.5 Kb, format: <span class="qualsolid">qualsolid</span>, database: \? Info: uploaded file' )
self.check_metadata_for_string( 'Change data type value="qualsolid" selected="yes">qualsolid' )
latest_hda = sa_session.query( galaxy.model.HistoryDatasetAssociation ) \
.order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ) \
.first()
assert latest_hda is not None, "Problem retrieving qualsolid hda from the database"
if not latest_hda.name == 'qualscores.qualsolid' and not latest_hda.extension == 'qualsolid':
raise AssertionError, "qualsolid data type was not correctly sniffed."
def test_075_tabular_datatype( self ):
"""Testing correctly sniffing tabular data type upon upload"""
self.upload_file( '1.tabular' )
self.verify_dataset_correctness( '1.tabular' )
self.check_history_for_string( '1.tabular format: <span class="tabular">tabular</span>, database: \? Info: uploaded file' )
self.check_metadata_for_string( 'value="1.tabular" value="\?"' )
self.check_metadata_for_string( 'Change data type selected value="tabular" selected="yes"' )
latest_hda = sa_session.query( galaxy.model.HistoryDatasetAssociation ) \
.order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ) \
.first()
assert latest_hda is not None, "Problem retrieving tabular hda from the database"
if not latest_hda.name == '1.tabular' and not latest_hda.extension == 'tabular':
raise AssertionError, "tabular data type was not correctly sniffed."
def test_080_wig_datatype( self ):
"""Testing correctly sniffing wig data type upon upload"""
self.upload_file( '1.wig' )
self.verify_dataset_correctness( '1.wig' )
self.check_history_for_string( '1.wig format: <span class="wig">wig</span>, database: \? Info: uploaded file' )
self.check_metadata_for_string( 'value="1.wig" value="\?"' )
self.check_metadata_for_string( 'Change data type selected value="wig" selected="yes"' )
latest_hda = sa_session.query( galaxy.model.HistoryDatasetAssociation ) \
.order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ) \
.first()
assert latest_hda is not None, "Problem retrieving wig hda from the database"
if not latest_hda.name == '1.wig' and not latest_hda.extension == 'wig':
raise AssertionError, "wig data type was not correctly sniffed."
def test_090_sam_datatype( self ):
"""Testing correctly sniffing sam format upon upload"""
self.upload_file( '1.sam' )
self.verify_dataset_correctness( '1.sam' )
self.check_history_for_string( '1.sam format: <span class="sam">sam</span>, database: \? Info: uploaded sam file' )
latest_hda = sa_session.query( galaxy.model.HistoryDatasetAssociation ) \
.order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ) \
.first()
assert latest_hda is not None, "Problem retrieving sam hda from the database"
if not latest_hda.name == '1.sam' and not latest_hda.extension == 'sam':
raise AssertionError, "sam data type was not correctly sniffed."
def test_095_fastq_datatype( self ):
"""Testing correctly sniffing fastq ( generic ) data type upon upload"""
self.upload_file( '2gen.fastq' )
self.verify_dataset_correctness( '2gen.fastq' )
self.check_history_for_string( '2gen.fastq format: <span class="fastq">fastq</span>, database: \? Info: uploaded fastq file' )
latest_hda = sa_session.query( galaxy.model.HistoryDatasetAssociation ) \
.order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ) \
.first()
assert latest_hda is not None, "Problem retrieving fastq hda from the database"
if not latest_hda.name == '2gen.fastq' and not latest_hda.extension == 'fastq':
raise AssertionError, "fastq data type was not correctly sniffed."
def test_0100_sff_datatype( self ):
"""Testing correctly sniffing sff format upon upload"""
self.upload_file( '1.sff' )
self.verify_dataset_correctness( '1.sff' )
self.check_history_for_string( 'format: <span class="sff">sff' )
latest_hda = sa_session.query( galaxy.model.HistoryDatasetAssociation ) \
.order_by( desc( galaxy.model.HistoryDatasetAssociation.table.c.create_time ) ) \
.first()
assert latest_hda is not None, "Problem retrieving sff hda from the database"
if not latest_hda.name == '1.sff' and not latest_hda.extension == 'sff':
raise AssertionError, "sff data type was not correctly sniffed."
def test_9999_clean_up( self ):
self.delete_history( id=self.security.encode_id( history1.id ) )
self.logout()
test/functional/test_user_info.py
+5 -4
View File
@@ -14,6 +14,7 @@ def get_latest_form(form_name):
.filter( galaxy.model.FormDefinitionCurrent.table.c.deleted==False ) \
.order_by( galaxy.model.FormDefinitionCurrent.table.c.create_time.desc() )
for fdc in fdc_list:
sa_session.refresh( fdc )
sa_session.refresh( fdc.latest_form )
if form_name == fdc.latest_form.name:
return fdc.latest_form
@@ -49,7 +50,7 @@ class TestUserInfo( TwillTestCase ):
type='CheckboxField',
required='optional')]
form_one = get_latest_form(form_one_name)
self.form_add_field(form_one.id, form_one.name, form_one.desc, form_one.type, field_index=len(form_one.fields), fields=fields)
self.form_add_field(form_one.current.id, form_one.name, form_one.desc, form_one.type, field_index=len(form_one.fields), fields=fields)
form_one_latest = get_latest_form(form_one_name)
assert len(form_one_latest.fields) == len(form_one.fields)+len(fields)
# create the second form
@@ -75,7 +76,7 @@ class TestUserInfo( TwillTestCase ):
type='CheckboxField',
required='optional')]
form_two = get_latest_form(form_two_name)
self.form_add_field(form_two.id, form_two.name, form_two.desc, form_two.type, field_index=len(form_one.fields), fields=fields)
self.form_add_field(form_two.current.id, form_two.name, form_two.desc, form_two.type, field_index=len(form_one.fields), fields=fields)
form_two_latest = get_latest_form(form_two_name)
assert len(form_two_latest.fields) == len(form_two.fields)+len(fields)
def test_005_user_reqistration_multiple_user_info_forms( self ):
@@ -103,7 +104,7 @@ class TestUserInfo( TwillTestCase ):
sa_session.add( form_two_latest.current )
sa_session.flush()
self.home()
self.visit_page('forms/manage?show_filter=Deleted')
self.visit_page('forms/manage?sort=create_time&f-deleted=True')
self.check_page_for_string(form_two_latest.name)
self.logout()
# user a new user with 'Student' user info form
@@ -157,7 +158,7 @@ class TestUserInfo( TwillTestCase ):
sa_session.add( form_one_latest.current )
sa_session.flush()
self.home()
self.visit_page('forms/manage?show_filter=Deleted')
self.visit_page('forms/manage?sort=create_time&f-deleted=True')
self.check_page_for_string(form_one_latest.name)
self.logout()
tools/data_source/upload.py
+23 -22
View File
@@ -9,6 +9,7 @@ from galaxy import eggs
# need to import model before sniff to resolve a circular import dependency
import galaxy.model
from galaxy.datatypes import sniff
from galaxy.datatypes.binary import sniffable_binary_formats, unsniffable_binary_formats
from galaxy import util
from galaxy.util.json import *
@@ -200,25 +201,29 @@ def add_file( dataset, json_file, output_path ):
ext = dataset.file_type
if not data_type:
if check_binary( dataset.path ):
if dataset.is_binary is not None:
data_type = 'binary'
ext = dataset.file_type
else:
parts = dataset.name.split( "." )
if len( parts ) > 1:
ext = parts[1].strip().lower()
if not( ext == 'ab1' or ext == 'scf' ):
file_err( 'The uploaded file contains inappropriate content', dataset, json_file )
data_type = 'binary'
binary_ok = False
parts = dataset.name.split( "." )
if len( parts ) > 1:
ext = parts[1].strip().lower()
if ext in unsniffable_binary_formats and dataset.file_type == ext:
binary_ok = True
elif ext in unsniffable_binary_formats and dataset.file_type != ext:
err_msg = "You must manually set the 'File Format' to '%s' when uploading %s files." % ( ext.capitalize(), ext )
file_err( err_msg, dataset, json_file )
return
if not binary_ok and ext in sniffable_binary_formats:
# Sniff the file to confirm it's data type
tmp_ext = sniff.guess_ext( dataset.path )
if tmp_ext == ext:
binary_ok = True
else:
err_msg = "The content of the file does not match its type (%s)." % ext.capitalize()
file_err( err_msg, dataset, json_file )
return
if ext == 'ab1' and dataset.file_type != 'ab1':
file_err( "You must manually set the 'File Format' to 'Ab1' when uploading ab1 files.", dataset, json_file )
return
elif ext == 'scf' and dataset.file_type != 'scf':
file_err( "You must manually set the 'File Format' to 'Scf' when uploading scf files.", dataset, json_file )
return
else:
ext = 'binary'
data_type = 'binary'
if not binary_ok:
file_err( 'The uploaded file contains inappropriate content', dataset, json_file )
return
if not data_type:
# We must have a text file
if check_html( dataset.path ):
@@ -234,10 +239,6 @@ def add_file( dataset, json_file, output_path ):
else:
ext = dataset.file_type
data_type = ext
elif data_type == 'binary' and ext == 'auto':
# currently we are only sniffing sff binary files
ext = sniff.guess_ext( dataset.path )
data_type = ext
# Save job info for the framework
if ext == 'auto' and dataset.ext:
ext = dataset.ext
tools/data_source/upload.xml
+6
View File
@@ -181,6 +181,12 @@ A binary sequence file in 'scf' format with a '.scf' file extension. You must m
-----
**Sff**
A binary file in 'Standard Flowgram Format' with a '.sff' file extension.
-----
**Tabular (tab delimited)**
Any data in tab delimited format (tabular)
tools/extract/extract_genomic_dna.xml
+2 -2
View File
@@ -1,4 +1,4 @@
<tool id="Extract genomic DNA 1" name="Extract Genomic DNA" version="2.2.0">
<tool id="Extract genomic DNA 1" name="Extract Genomic DNA" version="2.2.1">
<description>using coordinates from assembled/unassembled genomes</description>
<command interpreter="python">extract_genomic_dna.py $input $out_file1 -1 ${input.metadata.chromCol},${input.metadata.startCol},${input.metadata.endCol},${input.metadata.strandCol} -d $dbkey -o $out_format -g ${GALAXY_DATA_INDEX_DIR}</command>
<inputs>
@@ -12,7 +12,7 @@
</param>
</inputs>
<outputs>
<data format="fasta" name="out_file1">
<data format="fasta" name="out_file1" metadata_source="input">
<change_format>
<when input="out_format" value="interval" format="interval" />
</change_format>
tools/extract/liftOver_wrapper.xml
+1 -1
View File
@@ -1,4 +1,4 @@
<tool id="liftOver1" name="Convert genome coordinates" version="1.0.1">
<tool id="liftOver1" name="Convert genome coordinates" version="1.0.2">
<description> between assemblies and genomes</description>
<command interpreter="python">liftOver_wrapper.py $input "$out_file1" "$out_file2" $dbkey $to_dbkey $minMatch</command>
<inputs>