Raw content of BioMart::Configurator
<![CDATA[# $Id: Configurator.pm,v 1.17.2.1 2008/07/04 16:12:59 syed Exp $
#
# BioMart module for BioMart::Configurator
#
# You may distribute this module under the same terms as perl
# itself.
# POD documentation - main docs before the code
=head1 NAME
BioMart::Configurator
=head1 SYNOPSIS
TODO: Synopsis here.
=head1 DESCRIPTION
Each dataset is associated with a BioMart::Configurator
object. This object is shared among all BioMart::Dataset
objects. It holds information about database connectivity
(getConnectionAttribute()) and knows how to parse the
configuration file for a dataset (getConfigurationTree()).
=head1 AUTHOR - Arek Kasprzyk, Syed Haider, Richard Holland, Darin London, Damian Smedley
=head1 CONTACT
This module is part of the BioMart project
http://www.biomart.org
Questions can be posted to the mart-dev mailing list:
mart-dev@ebi.ac.uk
=head1 METHODS
=cut
#------------------------------------------------------------------------
package BioMart::Configurator;
use strict;
use warnings;
use XML::Simple qw(:strict);
use Compress::Zlib;
use Data::Dumper;
use Storable qw(store retrieve freeze nfreeze thaw);
local $Storable::Deparse = 1;
$Storable::forgive_me = 1;
use Cwd;
use BioMart::Web::CGIXSLT;
use DBI;
use Socket;
use BioMart::Configuration::ConfigurationTree;
use BioMart::Configuration::AttributeTree;
use BioMart::Configuration::FilterTree;
use BioMart::Configuration::AttributeGroup;
use BioMart::Configuration::FilterGroup;
use BioMart::Configuration::AttributeCollection;
use BioMart::Configuration::FilterCollection;
use BioMart::Configuration::Attribute;
use BioMart::Configuration::Option;
use BioMart::Configuration::PushAction;
use BioMart::Configuration::BooleanFilter;
use BioMart::Configuration::ValueFilter;
use BioMart::Configuration::AttributeList;
use BioMart::Configuration::FilterList;
use BioMart::Configuration::FilterList_List;
use base qw(BioMart::Root);
BEGIN{
# We want to use XML::Parser if installed, as it's faster than XML::SAX
no strict 'refs';
my $fail;
unless( 'XML::'->{'Parser::'} ){ # Check if already used
eval "require XML::Parser";
if( $@ ){ $fail ++ }
else{ XML::Parser->import() }
}
unless( $fail ){ $XML::Simple::PREFERRED_PARSER = 'XML::Parser' }
}
#------------------------------------------------------------------------
=head2 new
Usage : my $configurator =
BioMart::Configurator->new(
$registry, $connectionAttributes);
Description: Creates a BioMart::Configurator object.
The $registry argument should be a
BioMart::Registry object, and $location a
BioMart::Configuration::Location object
}
Return type: A BioMart::Configurator object.
Exceptions :
Caller : BioMart::Initializer::getRegistry()
=cut
sub _new {
my ($self, $registry, $location, @params) = @_;
$self->SUPER::_new(@params);
$self->attr('registry', $registry);
$self->attr('location', $location);
}
#------------------------------------------------------------------------
=head2 getConfigurationTree
Usage : my $configurationTree =
$configurator->getConfigurationTree($virtualSchema,
$dataSetName);
Description: Builds the configuration tree for the named dataset in the
given virtualSchema using the XML pulled out of the database
specified in the connection parameters for $dataSetName, if it does
not already exists on disk
Return type: BioMart::Configuration::ConfigurationTree
Exceptions :
Caller :
=cut
sub getConfigurationTree {
my ($self, $virtualSchema, $dataSetName, $interfaceType,$dsCounter) = @_;
my $registry = $self->get('registry');
my $dataSet = $registry->getDatasetByName($virtualSchema, $dataSetName);
#--------------------------------------
my $xml;
my $xmlFile = $registry->getDirPath();
$xmlFile .= $virtualSchema."/XML/";
$xmlFile .= $self->get('location')->name().".".$dataSetName.".".$interfaceType;
#$xmlFile .= $self->get('location')->database().".".$dataSetName.".".$interfaceType;
if(-e $xmlFile) # if xml file exists on disk
{
$xml = ${retrieve($xmlFile)};
print STDERR $self->get('location')->name(), "...", $dataSetName, "...", $interfaceType, "...", "Retrieving xml from DISK: ";
#print STDERR $self->get('location')->database(), "...", $dataSetName, "...", $interfaceType, "...", "Retrieving xml from DISK: ";
}
else # Get XML from the appropriate server
{
$xml = $self->get('location')->getDatasetConfigXML($virtualSchema,
$dataSetName,
$interfaceType,
$dsCounter);
# same funny character ü comes, and XML Parser moans. for pancreasExpression DB,
# we request ensembl datasets from webservice and on our side, parser crashes
# $xml =~ s/Müller/Muller/mg;
$xml =~ s/M[^a-zA-Z]{1}ller/Muller/mg;
#print STDERR "\n\n", $xml;
my $tempXMLHash = XMLin($xml, forcearray => [qw(AttributePage AttributeGroup
AttributeCollection AttributeDescription FilterPage FilterGroup
FilterCollection FilterDescription Importable Exportable Key
MainTable BatchSize SeqModule Option PushAction)], keyattr => []);
my $softwareVersion = $tempXMLHash->{'softwareVersion'};
# Transformation from 0.4 to 0.5 & 0.6
if (!$softwareVersion || ($softwareVersion eq '0.4'))
{
# 0.4 TO 0.5
print STDERR "-> upgrading to 0.5 ... ";
my $params=BioMart::Web::CGIXSLT::read_https();
open(STDOUTTEMP, ">temp.xml");
print STDOUTTEMP $xml;
close(STDOUTTEMP);
$params->{'source'} = 'temp.xml';
$params->{'style'} = $registry->getDirPath().'../mart_0_4_0_5.xsl';
my $new_xml;
eval{$new_xml=BioMart::Web::CGIXSLT::transform();};
if($@){BioMart::Web::CGIXSLT::print_error("Exception: Configurator Cannot parse xml as per xsl. $@\n"); exit;};
#Now, we are printing and saving what we get
$xml = BioMart::Web::CGIXSLT::print_output($new_xml);
if (-e 'temp.xml') {
unlink 'temp.xml';
}
# 0.5 TO 0.6
print STDERR "-> upgrading to 0.6/0.7 ... ";
$params=();
$params=BioMart::Web::CGIXSLT::read_https();
# ENSEMBL 37 & 38 crashes during this transformation for dataset evoc_cell_type by XML:Parser
# used by CGIXSLT. The funny character ü comes and is lost after first transformation
# $xml =~ s/\<Option displayName=\"M.*ller cell\" internalName=\"m.*ller_cell\" isSelectable=\"true\" value=\"M.*ller cell\" displayType=\"text\" multipleValues=\"1\" graph=\"\" style=\"\" autoCompletion=\"\"\/\>/\<Option displayName=\"Müller cell\" internalName=\"müller_cell\" isSelectable=\"true\" value=\"Müller cell\" displayType=\"text\" multipleValues=\"1\" graph=\"\" style=\"\" autoCompletion=\"\"\/\>/mg;
open(STDOUTTEMP, ">temp.xml");
print STDOUTTEMP $xml;
close(STDOUTTEMP);
$params->{'source'} = 'temp.xml';
$params->{'style'} = $registry->getDirPath().'../mart_0_5_0_6.xsl';
eval{$new_xml=BioMart::Web::CGIXSLT::transform();};
if($@){BioMart::Web::CGIXSLT::print_error("Exception: Configurator Cannot parse xml as per xsl. $@\n"); exit;};
#Now, we are printing and saving what we get
$xml = BioMart::Web::CGIXSLT::print_output($new_xml);
if (-e 'temp.xml') {
unlink 'temp.xml';
}
}
# Transform from 0.5 to 0.6
if ($softwareVersion && $softwareVersion eq '0.5')
{
# 0.5 TO 0.6
print STDERR "-> upgrading to 0.6/0.7 ... ";
my $params=BioMart::Web::CGIXSLT::read_https();
open(STDOUTTEMP, ">temp.xml");
print STDOUTTEMP $xml;
close(STDOUTTEMP);
$params->{'source'} = 'temp.xml';
$params->{'style'} = $registry->getDirPath().'../mart_0_5_0_6.xsl';
my $new_xml;
eval{$new_xml=BioMart::Web::CGIXSLT::transform();};
if($@){BioMart::Web::CGIXSLT::print_error("Exception: Configurator Cannot parse xml as per xsl. $@\n"); exit;};
#Now, we are printing and saving what we get
$xml = BioMart::Web::CGIXSLT::print_output($new_xml);
if (-e 'temp.xml') {
unlink 'temp.xml';
}
}
store(\$xml, $xmlFile);
}
#--------------------------------------
unless ($xml) {
BioMart::Exception::Configuration->throw("Could not get xml for $dataSetName, interface $interfaceType\n");
}
# if want contents to be forced to be arrays even when there is a single
# entry should set in the forcearray options
my $xmlHash = XMLin($xml, forcearray => [qw(AttributePage AttributeGroup
AttributeCollection AttributeDescription AttributeList FilterPage FilterGroup
FilterCollection FilterDescription Importable Exportable Key
MainTable BatchSize SeqModule Option PushAction)], keyattr => []);
my $configurationTree = BioMart::Configuration::ConfigurationTree->new(
'dataSetName' => $dataSetName,
);
# HERE XML version is 0.5 for our local marts and NONE for dicty and wormbase
#open(STDVER,">>/homes/syed/Desktop/temp2/biomart-web/lib/BioMart/Configuration/version");
#my $softwareVersion = $xmlHash->{'softwareVersion'};
#print STDVER "!!!! DATASET $dataSetName Version: $softwareVersion ";
#print STDVER "\n";
#close(STDVER);
# #TODO: deal with softwareVersion test
# my $softwareVersion = $xmlHash->{'softwareVersion'};
# if (!$softwareVersion) {
# warn("!!!! DATASET $dataSetName Version does NOT exist ") ;
# }
# elsif ( $softwareVersion ne '0.5') {
# warn("!!!! DATASET $dataSetName Version: $softwareVersion ") ;
# }
# #TODO: implement noCount functionality for datasets with it set
# my $noCount = $xmlHash->{'noCount'};
# warn("!!!! DATASET $dataSetName HAS NO COUNT SET ") if ($noCount && $noCount == 1);
#resticted primary key access
my $restricted_pk = $xmlHash->{'primaryKeyRestriction'};
if ($restricted_pk) {
$configurationTree->primaryKeyRestriction($restricted_pk);
}
#entry label
my $entry_label = $xmlHash->{'entryLabel'};
if ($entry_label) {
$configurationTree->entryLabel($entry_label);
}
#optional parameters
my $opt_params = $xmlHash->{'optional_parameters'};
if ($opt_params) {
$configurationTree->optionalParameters($opt_params);
}
#default dataset
if ($xmlHash->{'defaultDataset'}
&& $xmlHash->{'defaultDataset'} eq 'true') {
$configurationTree->defaultDataset('true');
}
#visible on filter page
if ($xmlHash->{'visibleFilterPage'}
&& $xmlHash->{'visibleFilterPage'} == 1) {
$configurationTree->visibleFilterPage('true');
}
#martUsers
my $mart_users = $xmlHash->{'martUsers'};
$configurationTree->mart_Users($mart_users);
#xml version, would help in deciding what should be the version of xml query
my $softwareVersion = $xmlHash->{'softwareVersion'};
if (!$softwareVersion)
{
$configurationTree->software_version('0.4');# special case for dicty
}
else
{
$configurationTree->software_version($softwareVersion);
}
# ATTRIBUTES
foreach my $xmlAttributeTree (@{ $xmlHash->{'AttributePage'} }) {
next if ($xmlAttributeTree->{'hidden'}
&& $xmlAttributeTree->{'hidden'} eq 'true');
my $outFormats = $xmlAttributeTree->{'outFormats'};
$outFormats =~ s/,,/,/g if ($outFormats);
my $attributeTree = BioMart::Configuration::AttributeTree->new(
'name' => $xmlAttributeTree->{'internalName'},
'displayName' => $xmlAttributeTree->{'displayName'},
'description' => $xmlAttributeTree->{'description'},
'hideDisplay' => $xmlAttributeTree->{'hideDisplay'},
'outFormats' => $outFormats,
'maxSelect' => $xmlAttributeTree->{'maxSelect'},
);
foreach my $xmlAttributeGroup
(@{ $xmlAttributeTree->{'AttributeGroup'} }) {
next if ($xmlAttributeGroup->{'hidden'}
&& $xmlAttributeGroup->{'hidden'} eq 'true');
my $attributeGroup = BioMart::Configuration::AttributeGroup->new(
'name' => $xmlAttributeGroup->{'internalName'},
'displayName' => $xmlAttributeGroup->{'displayName'},
'description' => $xmlAttributeGroup->{'description'},
'maxSelect' => $xmlAttributeGroup->{'maxSelect'},
);
foreach my $xmlAttributeCollection
(@{ $xmlAttributeGroup->{'AttributeCollection'} }) {
next if ($xmlAttributeCollection->{'hidden'}
&& $xmlAttributeCollection->{'hidden'}eq 'true');
my $attributeCollection =
BioMart::Configuration::AttributeCollection->new(
'name' => lc($xmlAttributeCollection->{'internalName'}),
'displayName' => $xmlAttributeCollection->{'displayName'},
'description' => $xmlAttributeCollection->{'description'},
'maxSelect' => $xmlAttributeCollection->{'maxSelect'},
'selectAll' => $xmlAttributeCollection->{'enableSelectAll'} || 'false',
);
foreach my $xmlAttribute
(@{ $xmlAttributeCollection->{'AttributeDescription'} }) {
next if ($xmlAttribute->{'hidden'}
&& $xmlAttribute->{'hidden'} eq 'true');
my $attribute;
if ($xmlAttribute->{'pointerDataset'}
&& $xmlAttribute->{'pointerInterface'}
&& ($xmlAttribute->{'pointerAttribute'}
|| $xmlAttribute->{'pointerFilter'})){
next;#add placeholders after createAllLinks
}
else{
$attribute =
BioMart::Configuration::Attribute->new(
'name' => lc($xmlAttribute->{'internalName'}),
'displayName' => $xmlAttribute->{'displayName'},
'description' => $xmlAttribute->{'description'},
'imageURL' => $xmlAttribute->{'imageURL'},
'table' => $xmlAttribute->{'tableConstraint'},
'relational_attribute' => $xmlAttribute->{'field'},
'key' => lc($xmlAttribute->{'key'}),# lc to keep oracle happy
'width' => $xmlAttribute->{'maxLength'},
'link' => $xmlAttribute->{'linkoutURL'},
'datasetLink' => $xmlAttribute->{'datasetLink'},
'default' => $xmlAttribute->{'default'},
'dependsOnType' => $xmlAttribute->{'dependsOnType'},
'dependsOn' => $xmlAttribute->{'dependsOn'},
'dataSetName' => $dataSetName,
'interface' => $interfaceType,
);
$attributeCollection->addAttribute($attribute);
}
}
foreach my $xmlAttribute
(@{ $xmlAttributeCollection->{'AttributeList'} }) {
my $attribute;
$attribute =
BioMart::Configuration::AttributeList->new(
'name' => lc($xmlAttribute->{'internalName'}),
'displayName' => $xmlAttribute->{'displayName'},
'description' => $xmlAttribute->{'description'},
'imageURL' => $xmlAttribute->{'imageURL'},
'table' => $xmlAttribute->{'tableConstraint'},
'relational_attribute' => $xmlAttribute->{'field'},
'key' => lc($xmlAttribute->{'key'}),# lc to keep oracle happy
'width' => $xmlAttribute->{'maxLength'},
'link' => $xmlAttribute->{'linkoutURL'},
'datasetLink' => $xmlAttribute->{'datasetLink'},
'default' => $xmlAttribute->{'default'},
'dependsOnType' => $xmlAttribute->{'dependsOnType'},
'dependsOn' => $xmlAttribute->{'dependsOn'},
'attribute_string' => $xmlAttribute->{'attributes'},
'dataSetName' => $dataSetName,
'interface' => $interfaceType,
);
$attributeCollection->addAttribute($attribute);
}
$attributeGroup->addCollection($attributeCollection);
}
$attributeTree->addAttributeGroup($attributeGroup);
}
$configurationTree->addAttributeTree($attributeTree);
}
# FILTERS
foreach my $xmlFilterTree (@{ $xmlHash->{'FilterPage'} }) {
next if ($xmlFilterTree->{'hidden'}
&& $xmlFilterTree->{'hidden'} eq 'true');
my $filterTree = BioMart::Configuration::FilterTree->new(
'name' => $xmlFilterTree->{'internalName'},
'displayName' => $xmlFilterTree->{'displayName'},
'hideDisplay' => $xmlFilterTree->{'hideDisplay'}
);
foreach my $xmlFilterGroup (@{ $xmlFilterTree->{'FilterGroup'} }) {
next if ($xmlFilterGroup->{'hidden'}
&& $xmlFilterGroup->{'hidden'} eq 'true');
my $filterGroup = BioMart::Configuration::FilterGroup->new(
'name' => $xmlFilterGroup->{'internalName'},
'displayName' => $xmlFilterGroup->{'displayName'},
'description' => $xmlFilterGroup->{'description'},
);
foreach my $xmlFilterCollection
(@{ $xmlFilterGroup->{'FilterCollection'} }) {
next if ($xmlFilterCollection->{'hidden'}
&& $xmlFilterCollection->{'hidden'} eq 'true');
my $filterCollection =
BioMart::Configuration::FilterCollection->new(
'name' => lc($xmlFilterCollection->{'internalName'}),
'displayName' => $xmlFilterCollection->{'displayName'},
'description' => $xmlFilterCollection->{'description'},
);
foreach my $xmlFilter
(@{ $xmlFilterCollection->{'FilterDescription'} }) {
next if ($xmlFilter->{'hidden'}
&& $xmlFilter->{'hidden'} eq 'true');
my $attribute;
$attribute = $configurationTree->
getAttributeByName($xmlFilter->{'internalName'});
if (!$attribute){
$attribute = BioMart::Configuration::Attribute->new(
'name' => lc($xmlFilter->{'internalName'}),
'imageURL' => $xmlFilter->{'imageURL'},
'displayName' => $xmlFilter->{'displayName'},
'description' => $xmlFilter->{'description'},
'table' => $xmlFilter->{'tableConstraint'},
'relational_attribute' => $xmlFilter->{'field'},
'key' => lc($xmlFilter->{'key'}),
'dependsOnType' => $xmlFilter->{'dependsOnType'},
'dependsOn' => $xmlFilter->{'dependsOn'},
'dataSetName' => $dataSetName,
'interface' => $interfaceType,
);
}
my $filter;
if ($xmlFilter->{'pointerDataset'}
&& $xmlFilter->{'pointerInterface'} &&
$xmlFilter->{'pointerFilter'}){
next;
}
# FILTER_LIST_HACK-part 1
elsif ($xmlFilter->{'filterList'}) {
#print STDERR "\nprocessing FILTER LIST: ", $xmlFilter->{'filterList'}, "\n";
$filter = BioMart::Configuration::FilterList_List->new(
'name' => $xmlFilter->{'internalName'},
'displayName' => $xmlFilter->{'displayName'},
'description' => $xmlFilter->{'description'},
'filter_string' => $xmlFilter->{'filterList'},
'orderby_string' => $xmlFilter->{'orderby_string'},
'dataSetName' => $dataSetName,
'interface' => $interfaceType,
'type' => $xmlFilter->{'type'},
'displayType' => $xmlFilter->{'displayType'},
'hideDisplay' => $xmlFilter->{'hideDisplay'},
'legalQualifiers' => $xmlFilter->{'legal_qualifiers'},
);
# this is done once the configuration tree is populated, so we can find the filter Objects
# and associate them with this filterList. see code before importables
#foreach my $filterName (split (/,/, $xmlFilter->{'filterList'})) {
# my $filterListItem = $configurationTree->getFilterByName($filterName);
# print Dumper($filter);
# $filter->addFilter($filterListItem);
#}
}
elsif ($xmlFilter->{'type'}
&& $xmlFilter->{'type'} eq 'boolean'){
$filter = BioMart::Configuration::BooleanFilter->new(
'name' => $xmlFilter->{'internalName'},
'imageURL' => $xmlFilter->{'imageURL'},
'displayName' => $xmlFilter->{'displayName'},
'description' => $xmlFilter->{'description'},
'dataSetName' => $dataSetName,
'interface' => $interfaceType,
'buttonURL' => $xmlFilter->{'buttonURL'},
'setAttributePage' =>
$xmlFilter->{'setAttributePage'},
'type' => $xmlFilter->{'type'},
'dependsOnType' => $xmlFilter->{'dependsOnType'},
'dependsOn' => $xmlFilter->{'dependsOn'},
'hideDisplay' => $xmlFilter->{'hideDisplay'},
'legalQualifiers' => $xmlFilter->{'legal_qualifiers'},
);
$filter->attribute($attribute);
$filter->defaultOn($xmlFilter->{'defaultOn'});
$filter->setAttribute($xmlFilter->{'setAttribute'});
}
elsif ($xmlFilter->{'type'}
&& $xmlFilter->{'type'} eq 'boolean_num'){
# hack for 1,0,null snp filters
$filter =
BioMart::Configuration::BooleanFilter->new(
'name' => $xmlFilter->{'internalName'},
'imageURL' => $xmlFilter->{'imageURL'},
'displayName' => $xmlFilter->{'displayName'},
'description' => $xmlFilter->{'description'},
'dataSetName' => $dataSetName,
'interface' => $interfaceType,
'buttonURL' => $xmlFilter->{'buttonURL'},
'setAttributePage' =>
$xmlFilter->{'setAttributePage'},
'type' => $xmlFilter->{'type'},
'dependsOnType' => $xmlFilter->{'dependsOnType'},
'dependsOn' => $xmlFilter->{'dependsOn'},
'hideDisplay' => $xmlFilter->{'hideDisplay'},
'legalQualifiers' => $xmlFilter->{'legal_qualifiers'},
);
$filter->setNumberFlag();
$filter->attribute($attribute);
$filter->defaultOn($xmlFilter->{'defaultOn'});
$filter->setAttribute($xmlFilter->{'setAttribute'});
}
else
{
$filter =
BioMart::Configuration::ValueFilter->new(
'name' => $xmlFilter->{'internalName'},
'imageURL' => $xmlFilter->{'imageURL'},
'displayName' => $xmlFilter->{'displayName'},
'description' => $xmlFilter->{'description'},
'dataSetName' => $dataSetName,
'interface' => $interfaceType,
'buttonURL' => $xmlFilter->{'buttonURL'},
'setAttributePage' =>
$xmlFilter->{'setAttributePage'},
'type' => $xmlFilter->{'type'},
'dependsOnType' => $xmlFilter->{'dependsOnType'},
'dependsOn' => $xmlFilter->{'dependsOn'},
'hideDisplay' => $xmlFilter->{'hideDisplay'},
'legalQualifiers' => $xmlFilter->{'legal_qualifiers'},
);
$filter->attribute($attribute);
$filter->operation($xmlFilter->{'qualifier'});
$filter->otherFilters(
$xmlFilter->{'otherFilters'});
$filter->regexp($xmlFilter->{'regexp'});
$filter->defaultValue(
$xmlFilter->{'defaultValue'});
$filter->defaultOn($xmlFilter->{'defaultOn'});
$filter->setAttribute(
$xmlFilter->{'setAttribute'});
}
# cycle through Options - needs to use a recursive method
# as Options can contain further Options
foreach my $xmlOption (@{ $xmlFilter->{'Option'} }) {
next if ($xmlOption->{'hidden'}
&& $xmlOption->{'hidden'} eq 'true');
$filter = _addOption($filter,$xmlOption,
$dataSetName,$interfaceType,
$configurationTree);
}
if (@{ $xmlFilter->{'Option'} } > 200){
# safety guard for web performance
# later on set autoCompletion for these type filters
#$filter->displayType('text');
print STDERR ("\nWarning: Too many Options for filter [ ", $xmlFilter->{'internalName'}, " ] possible rendering problems for Martview ");
}
#else{
$filter->displayType($xmlFilter->{'displayType'});
#}
$filter->multipleValues($xmlFilter->{'multipleValues'});
# hack to test CONTAINER type multiSelect with bool radio buttons
#if($xmlFilter->{'type'} eq 'boolean_list')
#{
# $filter->multipleValues('1');
#}
$filter->style($xmlFilter->{'style'});
$filter->graph($xmlFilter->{'graph'});
$filter->autoCompletion($xmlFilter->{'autoCompletion'});
$filterCollection->addFilter($filter);
}
$filterGroup->addCollection($filterCollection);
}
$filterTree->addFilterGroup($filterGroup);
}
$configurationTree->addFilterTree($filterTree);
}
# FILTER_LIST_HACK-part 2
foreach my $filterTree (@{$configurationTree->getAllFilterTrees()}){
foreach my $group(@{$filterTree->getAllFilterGroups()}){
foreach my $collection (@{$group->getAllCollections()}){
foreach my $filter (@{$collection->getAllFilters()}){
if ($filter->isa("BioMart::Configuration::FilterList_List")) {
#print STDERR "\nassociating FilterList filters to its objects";
foreach my $filterName (split (/,/, $filter->filterString)) {
my $filterListItem = $configurationTree->getFilterByName($filterName);
#print STDERR "\n\tfound Filter: ", $filterListItem->name();
$filter->addFilter($filterListItem);
}
}
}
}
}
}
# Importables
my $extraAttTree = BioMart::Configuration::AttributeTree->new(
'name' => 'extra_importable_atts',
'displayName' => '',
'hideDisplay' => 'true'
);
my $extraAttGroup = BioMart::Configuration::AttributeGroup->new(
'name' => 'extra_importable_atts',
'displayName' => ''
);
my $extraAttCollection = BioMart::Configuration::AttributeCollection->new(
'name' => 'extra_importable_atts',
'displayName' => ''
);
IMP: foreach my $importable (@{ $xmlHash->{'Importable'} }) {
my $filterList = BioMart::Configuration::FilterList->new(
'name' => $importable->{'name'},
'displayName' => $importable->{'displayName'},
'description' => $importable->{'description'},
'linkName' => $importable->{'linkName'},
'linkVersion' => $importable->{'linkVersion'},
'filter_string' => $importable->{'filters'},
'orderby_string' => $importable->{'orderBy'},
'dataSetName' => $dataSetName,
'interface' => $interfaceType,
'type' => $importable->{'type'} || 'link'
);
foreach my $filterName (split (/,/, $importable->{'filters'})) {
my $filter =
$configurationTree->getFilterByName($filterName);
#could be an option type filter
unless ($filter) {
my $op = $configurationTree->getOptionByName($filterName);
#skip this importable if its filters are not available
next IMP unless ($op);
$filter = $op->filter;
}
# for attribute joing between datasets the attribute equivalent
# to the filter needs to be available in the configTree with
# the same internalName
if ($filter){
my $attribute = $filter->attribute;
if (!$configurationTree->getAttributeByName(
$attribute->name)){
$extraAttCollection->addAttribute($attribute);
}
$filterList->addFilter($filter);
}
}
my $importables = $dataSet->get('importables');
$importables->{$filterList->linkName}->{$interfaceType} =
$filterList;
$dataSet->set('importables', $importables);
}
$extraAttGroup->addCollection($extraAttCollection);
$extraAttTree->addAttributeGroup($extraAttGroup);
$configurationTree->addAttributeTree($extraAttTree);
# Exportables
EXP:foreach my $exportable (@{ $xmlHash->{'Exportable'} }) {
my $attributeList = BioMart::Configuration::AttributeList->new(
'name' => $exportable->{'name'},
'displayName' => $exportable->{'displayName'},
'description' => $exportable->{'description'},
'linkName' => $exportable->{'linkName'},
'linkVersion' => $exportable->{'linkVersion'},
'attribute_string' => $exportable->{'attributes'},
'orderby_string' => $exportable->{'orderBy'},
'dataSetName' => $dataSetName,
'interface' => $interfaceType,
'type' => $exportable->{'type'} || 'link'
);
if ($exportable->{'default'}) { $attributeList->setDefault()}
next EXP if($exportable->{'pointer'} && $exportable->{'pointer'} eq 'true'); # exportable is a placeholder - gtf
foreach my $attributeName (split (/,/, $exportable->{'attributes'})) {
#placeholder attribute exportable gtf in xmls upto 41, as there we dont have pointer='true'
next EXP if ($attributeName =~ /__/);
my $attribute = $configurationTree->getAttributeByName($attributeName);
$attributeList->addAttribute($attribute);
}
if ($exportable->{'orderBy'}) {
foreach my $attributeName (split (/,/, $exportable->{'orderBy'})) {
my $attribute =
$configurationTree->getAttributeByName($attributeName);
$attributeList->addOrderByAttribute($attribute);
}
}
my $exportables = $dataSet->get('exportables');
$exportables->{$attributeList->linkName()}->{$interfaceType} = $attributeList;
$dataSet->set('exportables', $exportables);
}
# MainTables
foreach my $main (@{ $xmlHash->{'MainTable'} }) {
next if ($xmlHash->{'type'} ne "TableSet");
my $mains = $dataSet->get('mains');
push @{ $mains }, $main;
$dataSet->set('mains', $mains);
}
# Keys
foreach my $key (@{ $xmlHash->{'Key'} }) {
next if ($xmlHash->{'type'} ne "TableSet");
my $keys = $dataSet->get('keys');
push @{ $keys }, lc($key);#to avoid oracle complications
$dataSet->set('keys', $keys);
}
# BatchSizes
foreach my $batchSize (@{ $xmlHash->{'BatchSize'} }) {
$dataSet->set('batch_size', $batchSize);
}
#SeqModules
foreach my $seqModule (@{ $xmlHash->{'SeqModule'} }) {
my $seqModules = $dataSet->get('seqModules');
$seqModules->{$seqModule->{'linkName'}}{'moduleName'} =
$seqModule->{'moduleName'};
$dataSet->set('seqModules', $seqModules);
}
print STDERR " OK\n";
$configurationTree->toXML($xml);
return $configurationTree;
}
sub _addOption {
my ($parentObject,$xmlOption,$dataSetName,$interfaceType,
$configurationTree) = @_;
my $option = BioMart::Configuration::Option->new(
'name' => $xmlOption->{'internalName'},
'displayName' => $xmlOption->{'displayName'},
'description' => $xmlOption->{'description'},
'dataSetName' => $dataSetName,
'value' => $xmlOption->{'value'}
);
$option->operation($xmlOption->{'qualifier'});
if ($xmlOption->{'tableConstraint'} && $xmlOption->{'field'}){#filterOption
my $attribute;
$attribute = $configurationTree->
getAttributeByName($xmlOption->{'internalName'});
if (!$attribute){
$attribute = BioMart::Configuration::Attribute->new(
'name' => $xmlOption->{'internalName'},
'imageURL' => $xmlOption->{'imageURL'},
'displayName' => $xmlOption->{'displayName'},
'description' => $xmlOption->{'description'},
'table' => $xmlOption->{'tableConstraint'},
'relational_attribute' => $xmlOption->{'field'},
'key' => lc($xmlOption->{'key'}),
'dataSetName' => $dataSetName,
'interface' => $interfaceType,
'dependsOnType' => $xmlOption->{'dependsOnType'},
'dependsOn' => $xmlOption->{'dependsOn'},
);
}
my $filter;
if ($xmlOption->{'type'} && $xmlOption->{'type'} eq 'boolean'){
$filter = BioMart::Configuration::BooleanFilter->new(
'name' => $xmlOption->{'internalName'},
'imageURL' => $xmlOption->{'imageURL'},
'displayName' => $xmlOption->{'displayName'},
'description' => $xmlOption->{'description'},
'dataSetName' => $dataSetName,
'interface' => $interfaceType,
'type' => $xmlOption->{'type'},
'dependsOnType' => $xmlOption->{'dependsOnType'},
'dependsOn' => $xmlOption->{'dependsOn'},
'legalQualifiers' => $xmlOption->{'legal_qualifiers'},
);
$filter->attribute($attribute);
$filter->setAttribute($xmlOption->{'setAttribute'});
}
elsif ($xmlOption->{'type'} && $xmlOption->{'type'} eq 'boolean_num'){
# hack for 1,0,null snp filters
$filter = BioMart::Configuration::BooleanFilter->new(
'name' => $xmlOption->{'internalName'},
'imageURL' => $xmlOption->{'imageURL'},
'displayName' => $xmlOption->{'displayName'},
'description' => $xmlOption->{'description'},
'dataSetName' => $dataSetName,
'interface' => $interfaceType,
'type' => $xmlOption->{'type'},
'dependsOnType' => $xmlOption->{'dependsOnType'},
'dependsOn' => $xmlOption->{'dependsOn'},
'legalQualifiers' => $xmlOption->{'legal_qualifiers'},
);
$filter->setNumberFlag();
$filter->attribute($attribute);
$filter->setAttribute($xmlOption->{'setAttribute'});
}
else{
$filter = BioMart::Configuration::ValueFilter->new(
'name' => $xmlOption->{'internalName'},
'description' => $xmlOption->{'description'},
'displayName' => $xmlOption->{'displayName'},
'imageURL' => $xmlOption->{'imageURL'},
'dataSetName' => $dataSetName,
'interface' => $interfaceType,
'buttonURL' => $xmlOption->{'buttonURL'},
'type' => $xmlOption->{'type'},
'dependsOnType' => $xmlOption->{'dependsOnType'},
'dependsOn' => $xmlOption->{'dependsOn'},
'legalQualifiers' => $xmlOption->{'legal_qualifiers'},
);
$filter->attribute($attribute);
$filter->operation($xmlOption->{'qualifier'});
$filter->setAttribute($xmlOption->{'setAttribute'});
}
$filter->displayType($xmlOption->{'displayType'});
$filter->multipleValues($xmlOption->{'multipleValues'});
$filter->style($xmlOption->{'style'});
$filter->graph($xmlOption->{'graph'});
$filter->autoCompletion($xmlOption->{'autoCompletion'});
$option->filter($filter);
}
# recursive call as Options can contain Options
foreach my $xmlSubOption(@{ $xmlOption->{'Option'} }) {
next if ($xmlSubOption->{'hidden'} &&
$xmlSubOption->{'hidden'} eq 'true');
$option = _addOption($option,$xmlSubOption,$dataSetName,
$interfaceType,$configurationTree);
}
# recursive call as Options can contain PushActions
foreach my $xmlPushAction(@{ $xmlOption->{'PushAction'} }) {
next if ($xmlPushAction->{'hidden'} &&
$xmlPushAction->{'hidden'} eq 'true');
$option = _addPushAction($option,$xmlPushAction,$dataSetName,
$interfaceType,$configurationTree);
}
$parentObject->addOption($option);
return $parentObject;
}
sub _addPushAction {
my ($parentObject,$xmlPushAction,$dataSetName,$interfaceType,
$configurationTree) = @_;
my $pushAction = BioMart::Configuration::PushAction->new(
'name' => $xmlPushAction->{'internalName'},
'ref' => $xmlPushAction->{'ref'},
'dataSetName' => $dataSetName,
);
# recursive call as PushActions can contain Options
foreach my $xmlSubOption(@{ $xmlPushAction->{'Option'} }) {
next if ($xmlSubOption->{'hidden'} &&
$xmlSubOption->{'hidden'} eq 'true');
$pushAction = _addOption($pushAction,$xmlSubOption,$dataSetName,
$interfaceType,$configurationTree);
}
$parentObject->addPushAction($pushAction);
return $parentObject;
}
sub resolveDependsOn {
my ($self, $configTree, $virtualSchemaName, $dsName, $interfaceName) = @_;
# Replace dependsOn attribute names with attribute objects.
foreach my $aTree (@{$configTree->getAllAttributeTrees()}) {
foreach my $aGroup (@{$aTree->getAllAttributeGroups()}) {
foreach my $aColl (@{$aGroup->getAllCollections()}) {
foreach my $a (@{$aColl->getAllAttributes()}) {
if ($a->dependsOn) {
foreach my $dependsOn (split(/,/,$a->dependsOn)) {
my $est = $a->name;
my $dependent = $configTree->getAttributeByName($dependsOn);
if (!$dependent) {
#print "Problem with $virtualSchemaName.$dsName.$interfaceName:\n";
#print " DependsOn link between ".$a->name." and $dependsOn not possible.\n";
}
else {
$dependent->addDependency($a->name);
}
}
}
if (UNIVERSAL::can($a,'attributeString')) {
foreach my $attributeName (split (/,/, $a->attributeString)) {
my $attribute = $configTree->getAttributeByName($attributeName);
if ($attribute) {
$a->addAttribute($attribute);
}
else {
# Search all attributes looking for one with pointedFrom
foreach my $aTree (@{$configTree->getAllAttributeTrees()}) {
foreach my $aGroup (@{$aTree->getAllAttributeGroups()}) {
foreach my $aColl (@{$aGroup->getAllCollections()}) {
foreach my $ra (@{$aColl->getAllAttributes()}) {
if ($ra->pointedFromAttribute and $ra->pointedFromAttribute eq $attributeName) {
$a->addAttribute($ra);
}
}
}
}
}
}
}
}
}
}
}
}
}
sub addPlaceHolderDatasets {
my ($self, $configTree, $virtualSchemaName) = @_;
# loop over all attributes and filters and convert as necessary
my $xml = $configTree->toXML();#cached
my $registry = $self->get('registry');
my $xmlHash = XMLin($xml, forcearray => [qw(AttributePage AttributeGroup
AttributeCollection AttributeDescription FilterPage FilterGroup
FilterCollection FilterDescription Importable Exportable Key MainTable
BatchSize SeqModule Option PushAction)], keyattr => []);
foreach my $xmlAttributeTree (@{ $xmlHash->{'AttributePage'} }) {
my $attributePage = $configTree->
getAttributeTreeByName($xmlAttributeTree->{'internalName'});
next if ($xmlAttributeTree->{'hidden'} &&
$xmlAttributeTree->{'hidden'} eq 'true');
foreach my $xmlAttributeGroup
(@{ $xmlAttributeTree->{'AttributeGroup'} }) {
my $attributeGroup = $attributePage->
getAttributeGroupByName($xmlAttributeGroup->{'internalName'});
next if ($xmlAttributeGroup->{'hidden'}
&& $xmlAttributeGroup->{'hidden'} eq 'true');
foreach my $xmlAttributeCollection
(@{ $xmlAttributeGroup->{'AttributeCollection'} }) {
my $attributeCollection = $attributeGroup->
getAttributeCollectionByName(
$xmlAttributeCollection->{'internalName'});
next if ($xmlAttributeCollection->{'hidden'}
&& $xmlAttributeCollection->{'hidden'}eq 'true');
foreach my $xmlAttribute
(@{ $xmlAttributeCollection->{'AttributeDescription'} }) {
next if ($xmlAttribute->{'hidden'} &&
$xmlAttribute->{'hidden'} eq 'true');
my $attribute;
# TODO:REMOVE FOR 0_5 - nb put in hack to convert 0_4
# style placeholders for now until all XML gets updated
if ( # $xmlAttribute->{'internalName'} =~ /\./ ||
($xmlAttribute->{'pointerDataset'} &&
$xmlAttribute->{'pointerInterface'} &&
$xmlAttribute->{'pointerAttribute'} || $xmlAttribute->{'pointerFilter'} )){
my ($pointerDatasetName, $pointerInterface);
# get real attribute from pointer dataset
if ($xmlAttribute->{'pointerDataset'}){
$pointerDatasetName =
$xmlAttribute->{'pointerDataset'};
$pointerInterface =
$xmlAttribute->{'pointerInterface'};
}
my $dataset =
$registry->getDatasetByName($virtualSchemaName,
$pointerDatasetName);
if (!$dataset){
warn(" WARNING: Pointer attributes from $pointerDatasetName will not be available as $pointerDatasetName not in registry\n");
next;
}
$dataset->getConfigurationTree($pointerInterface);
}
}
}
}
}
foreach my $xmlFilterTree (@{ $xmlHash->{'FilterPage'} }) {
my $filterPage = $configTree->getFilterTreeByName(
$xmlFilterTree->{'internalName'});
next if ($xmlFilterTree->{'hidden'} &&
$xmlFilterTree->{'hidden'} eq 'true');
foreach my $xmlFilterGroup (@{ $xmlFilterTree->{'FilterGroup'} }) {
my $filterGroup = $filterPage->getFilterGroupByName(
$xmlFilterGroup->{'internalName'});
next if ($xmlFilterGroup->{'hidden'} &&
$xmlFilterGroup->{'hidden'} eq 'true');
foreach my $xmlFilterCollection
(@{ $xmlFilterGroup->{'FilterCollection'} }) {
my $filterCollection = $filterGroup->getFilterCollectionByName
($xmlFilterCollection->{'internalName'});
next if ($xmlFilterCollection->{'hidden'} &&
$xmlFilterCollection->{'hidden'}eq 'true');
foreach my $xmlFilter
(@{ $xmlFilterCollection->{'FilterDescription'} }) {
next if ($xmlFilter->{'hidden'} &&
$xmlFilter->{'hidden'} eq 'true');
my $filter;
if ( ($xmlFilter->{'pointerDataset'}
&& $xmlFilter->{'pointerInterface'}
&& $xmlFilter->{'pointerFilter'})){
# get real filter from pointer dataset
my ($pointerDatasetName,$pointerInterface);
if ($xmlFilter->{'pointerDataset'}){
$pointerDatasetName =
$xmlFilter->{'pointerDataset'};
$pointerInterface =
$xmlFilter->{'pointerInterface'};
}
my $dataset =
$registry->getDatasetByName($virtualSchemaName,
$pointerDatasetName);
if (!$dataset){
warn(" WARNING: Pointer attributes from $pointerDatasetName will not be available as $pointerDatasetName not in registry\n");
next;
}
$dataset->getConfigurationTree($pointerInterface);
}
}
}
}
}
}
sub addPlaceHolders {
my ($self, $configTree, $virtualSchemaName, $dataSetName, $interface) = @_;
# loop over all attributes and filters and convert as necessary
my $xml = $configTree->toXML();#cached
my $registry = $self->get('registry');
my $dataSet = $registry->getDatasetByName($virtualSchemaName,
$dataSetName);
my $xmlHash = XMLin($xml, forcearray => [qw(AttributePage AttributeGroup
AttributeCollection AttributeDescription FilterPage FilterGroup
FilterCollection FilterDescription Importable Exportable Key MainTable
BatchSize SeqModule Option PushAction)], keyattr => []);
foreach my $xmlAttributeTree (@{ $xmlHash->{'AttributePage'} }) {
my $attributePage = $configTree->
getAttributeTreeByName($xmlAttributeTree->{'internalName'});
next unless $attributePage;
#next if ($xmlAttributeTree->{'hidden'} &&
# $xmlAttributeTree->{'hidden'} eq 'true');
foreach my $xmlAttributeGroup
(@{ $xmlAttributeTree->{'AttributeGroup'} }) {
my $attributeGroup = $attributePage->
getAttributeGroupByName($xmlAttributeGroup->{'internalName'});
next unless $attributeGroup;
#next if ($xmlAttributeGroup->{'hidden'}
# && $xmlAttributeGroup->{'hidden'} eq 'true');
foreach my $xmlAttributeCollection
(@{ $xmlAttributeGroup->{'AttributeCollection'} }) {
my $attributeCollection = $attributeGroup->
getAttributeCollectionByName(
$xmlAttributeCollection->{'internalName'});
next unless $attributeCollection;
#next if ($xmlAttributeCollection->{'hidden'}
# && $xmlAttributeCollection->{'hidden'}eq 'true');
foreach my $xmlAttribute
(@{ $xmlAttributeCollection->{'AttributeDescription'} }) {
#next if ($xmlAttribute->{'hidden'}
# && $xmlAttribute->{'hidden'}eq 'true');
my $attribute;
if ( ($xmlAttribute->{'pointerDataset'} &&
$xmlAttribute->{'pointerInterface'} &&
$xmlAttribute->{'pointerAttribute'} || $xmlAttribute->{'pointerFilter'} )){
my ($pointerDatasetName, $pointerInterface,
$pointerAttribute, $pointerFilter);
# get real attribute from pointer dataset
if ($xmlAttribute->{'pointerDataset'}){
$pointerDatasetName =
$xmlAttribute->{'pointerDataset'};
$pointerInterface =
$xmlAttribute->{'pointerInterface'};
$pointerAttribute =
$xmlAttribute->{'pointerAttribute'};
$pointerFilter =
$xmlAttribute->{'pointerFilter'};
}
my $pointerDataset = $registry->getDatasetByName(
$virtualSchemaName, $pointerDatasetName) || next;
my $pointerConfigurationTree = $pointerDataset->
getConfigurationTree($pointerInterface) || next;
if ($pointerFilter){
# have a placeholder filter within an attributePage
my $filter = $pointerConfigurationTree->
getFilterByName($pointerFilter) || next;
my $newName = $pointerFilter;# needed to work with current GenomicSequence module
# need to make copies incase placeholder
# shared by more than 1 dataset
my $new_filter;
if ($filter->isa
("BioMart::Configuration::BooleanFilter")){
$new_filter =
BioMart::Configuration::BooleanFilter->new(
'name' => $newName,#$filter->name,
'imageURL' => $filter->imageURL,
'displayName' => $filter->displayName,
'dataSetName' => $filter->dataSetName,
'interface' => $filter->interface,
'buttonURL' => $filter->buttonURL,
'setAttributePage' =>
$filter->setAttributePage,
'type' => $filter->type,
'dependsOn' => $filter->dependsOn,
'dependsOnType' => $filter->dependsOnType,
'hidden' => $xmlAttribute->{'hidden'},
'legalQualifiers' => $filter->legalQualifiers,
);
$new_filter->attribute($filter->attribute);
$new_filter->defaultOn($filter->defaultOn);
$new_filter->setAttribute($filter->setAttribute);
$new_filter->setNumberFlag($filter->getNumberFlag);
}
elsif ($filter->isa
("BioMart::Configuration::ValueFilter")){
$new_filter =
BioMart::Configuration::ValueFilter->new(
'name' => $newName,
'imageURL' => $filter->imageURL,
'displayName' => $filter->displayName,
'dataSetName' => $filter->dataSetName,
'interface' => $filter->interface,
'buttonURL' => $filter->buttonURL,
'setAttributePage' =>
$filter->setAttributePage,
'type' => $filter->type,
'hidden' => $xmlAttribute->{'hidden'},
'dependsOn' => $filter->dependsOn,
'dependsOnType' => $filter->dependsOnType,
'legalQualifiers' => $filter->legalQualifiers,
);
$new_filter->attribute($filter->attribute);
$new_filter->operation($filter->operation);
$new_filter->otherFilters($filter->otherFilters);
$new_filter->regexp($filter->regexp);
$new_filter->defaultValue($filter->defaultValue);
$new_filter->defaultOn($filter->defaultOn);
$new_filter->setAttribute($filter->setAttribute);
$new_filter->addOptions($filter->getAllOptions);
}
$new_filter->pointedFromDataset($dataSetName);
$new_filter->pointedFromInterface($interface);
if ($registry->getPath($virtualSchemaName,
$dataSetName,
$pointerDatasetName)){
# only add if valid link exists
$new_filter->displayType($filter->displayType);
$new_filter->multipleValues(
$filter->multipleValues);
$new_filter->style($filter->style);
$new_filter->graph($filter->graph);
$new_filter->autoCompletion(
$filter->autoCompletion);
$attributeCollection->addAttribute($new_filter);
# allow filters in attribute list
}
}
else{# add normal attribute to attributeCollection
my $newName = $pointerAttribute;
$attribute = $pointerConfigurationTree->
getAttributeByName($pointerAttribute) || next;
# need to make a copy as several datasets can
# share the same placeholder
my $new_attribute =
BioMart::Configuration::Attribute->new(
'name' => $newName,#$attribute->name,
'imageURL' => $attribute->imageURL,
'displayName' => $attribute->displayName,
'table' => $attribute->table,
'relational_attribute' =>
$attribute->relationalAttribute,
'key' => $attribute->key,
'width' => $attribute->width,
'link' => $attribute->link,
'datasetLink' => $attribute->datasetLink,
'default' => $attribute->default,
'hidden' => $xmlAttribute->{'hidden'},
'dataSetName' => $attribute->dataSetName,
'attributes' => $attribute->attributes,
'interface' => $attribute->interface,
'dependsOn' => $attribute->dependsOn,
'dependsOnType' => $attribute->dependsOnType
);
$new_attribute->pointedFromDataset($dataSetName);
$new_attribute->pointedFromInterface($interface);
$new_attribute->pointedFromAttribute($xmlAttribute->{'internalName'});
if ($registry->getPath($virtualSchemaName,
$dataSetName,
$pointerDatasetName)){
# only add if valid link exists
$attributeCollection->
addAttribute($new_attribute);
}
}
}
}
}
}
}
# FILTERS
foreach my $xmlFilterTree (@{ $xmlHash->{'FilterPage'} }) {
my $filterPage = $configTree->getFilterTreeByName(
$xmlFilterTree->{'internalName'});
next unless $filterPage;
#next if ($xmlFilterTree->{'hidden'} &&
# $xmlFilterTree->{'hidden'} eq 'true');
foreach my $xmlFilterGroup (@{ $xmlFilterTree->{'FilterGroup'} }) {
my $filterGroup = $filterPage->getFilterGroupByName(
$xmlFilterGroup->{'internalName'});
next unless $filterGroup;
#next if ($xmlFilterGroup->{'hidden'} &&
# $xmlFilterGroup->{'hidden'} eq 'true');
foreach my $xmlFilterCollection
(@{ $xmlFilterGroup->{'FilterCollection'} }) {
my $filterCollection = $filterGroup->getFilterCollectionByName
($xmlFilterCollection->{'internalName'});
next unless $filterCollection;
#next if ($xmlFilterCollection->{'hidden'} &&
# $xmlFilterCollection->{'hidden'}eq 'true');
foreach my $xmlFilter
(@{ $xmlFilterCollection->{'FilterDescription'} }) {
#next if ($xmlFilter->{'hidden'} &&
# $xmlFilter->{'hidden'} eq 'true');
my $filter;
if ( ($xmlFilter->{'pointerDataset'}
&& $xmlFilter->{'pointerInterface'}
&& $xmlFilter->{'pointerFilter'})){
# get real filter from pointer dataset
my ($pointerDatasetName,$pointerInterface,
$pointerFilter);
if ($xmlFilter->{'pointerDataset'}){
$pointerDatasetName =
$xmlFilter->{'pointerDataset'};
$pointerInterface =
$xmlFilter->{'pointerInterface'};
$pointerFilter =
$xmlFilter->{'pointerFilter'};
}
my $pointerDataset = $registry->getDatasetByName
($virtualSchemaName, $pointerDatasetName) || next;
my $pointerConfigurationTree = $pointerDataset->
getConfigurationTree($pointerInterface) || next;
$filter = $pointerConfigurationTree->getFilterByName
($pointerFilter) || next;
my $newName = $pointerFilter;
if ($configTree->getFilterByName($newName)){
warn("Placeholder Filter $newName from $pointerDatasetName has an internalName clash in dataset $dataSetName\n");
next;
}
# need to make copies incase placeholder shared by
# more than 1 dataset
my $new_filter;
if ($filter->isa
("BioMart::Configuration::BooleanFilter")){
$new_filter =
BioMart::Configuration::BooleanFilter->new(
'name' => $newName,
'imageURL' => $filter->imageURL,
'displayName' => $filter->displayName,
'dataSetName' => $filter->dataSetName,
'interface' => $filter->interface,
'buttonURL' => $filter->buttonURL,
'hidden' => $xmlFilter->{'hidden'},
'setAttributePage' =>
$filter->setAttributePage,
'type' => $filter->type,
'dependsOn' => $filter->dependsOn,
'dependsOnType' => $filter->dependsOnType,
'legalQualifiers' => $filter->legalQualifiers,
);
$new_filter->attribute($filter->attribute);
$new_filter->defaultOn($filter->defaultOn);
$new_filter->setAttribute($filter->setAttribute);
$new_filter->setNumberFlag($filter->getNumberFlag);
$new_filter->addOptions($filter->getAllOptions);
}
elsif ($filter->isa
("BioMart::Configuration::ValueFilter")){
$new_filter =
BioMart::Configuration::ValueFilter->new(
'name' => $newName,
'imageURL' => $filter->imageURL,
'displayName' => $filter->displayName,
'dataSetName' => $filter->dataSetName,
'interface' => $filter->interface,
'buttonURL' => $filter->buttonURL,
'hidden' => $xmlFilter->{'hidden'},
'setAttributePage' =>
$filter->setAttributePage,
'type' => $filter->type,
'dependsOn' => $filter->dependsOn,
'dependsOnType' => $filter->dependsOnType,
'legalQualifiers' => $filter->legalQualifiers,
);
$new_filter->attribute($filter->attribute);
$new_filter->operation($filter->operation);
$new_filter->otherFilters($filter->otherFilters);
$new_filter->regexp($filter->regexp);
$new_filter->defaultValue($filter->defaultValue);
$new_filter->defaultOn($filter->defaultOn);
$new_filter->setAttribute($filter->setAttribute);
$new_filter->addOptions($filter->getAllOptions);
}
$new_filter->pointedFromDataset($dataSetName);
$new_filter->pointedFromInterface($interface);
if ($registry->getPath($virtualSchemaName,
$pointerDatasetName,
$dataSetName)){
# only add if valid link exists
# add new types
$new_filter->displayType($filter->displayType);
$new_filter->multipleValues(
$filter->multipleValues);
$new_filter->style($filter->style);
$new_filter->graph($filter->graph);
$new_filter->autoCompletion(
$filter->autoCompletion);
$filterCollection->addFilter($new_filter);
}
}
}
}
}
}
# Deal with exportables that contained placeholders
EXP: foreach my $exportable (@{ $xmlHash->{'Exportable'} })
{
# exportable is a placeholder - gtf __ check should be useless from ensembl 42 but need to keep it here for backward compatibility
if (($exportable->{'attributes'} =~ /__/) || ($exportable->{'pointer'} && $exportable->{'pointer'} eq 'true'))
{
my $attributeList = BioMart::Configuration::AttributeList->new(
'name' => $exportable->{'name'},
'displayName' => $exportable->{'displayName'},
'linkName' => $exportable->{'linkName'},
'linkVersion' => $exportable->{'linkVersion'},
'attribute_string' => $exportable->{'attributes'},
'orderby_string' => $exportable->{'orderBy'},
'dataSetName' => $dataSetName,
'interface' => $interface,
'type' => $exportable->{'type'} || 'link'
);
if ($exportable->{'default'}) { $attributeList->setDefault()}
foreach my $attributeName (split (/,/, $exportable->{'attributes'})) {
# with new placeholder change the dataset__ part is stripped
# from the attribute name but we need this part in the exportable
# to indicate should be done here rather than usual place for exp
my $attributeWithName = $attributeName;
if($attributeName =~ m/__/) # test for old style gtf exportable, ens 41 and before
{
my @attributeName = split(/__/,$attributeName);
$attributeWithName = $attributeName[1];
}
my $attribute = $configTree->getAttributeByName($attributeWithName);
$attributeList->addAttribute($attribute);
}
if ($exportable->{'orderBy'}) {
foreach my $attributeName (split (/,/, $exportable->{'orderBy'})) {
my $attributeWithName = $attributeName;
if($attributeName =~ m/__/) # test for old style gtf exportable, ens 41 and before
{
my @attributeName = split(/__/,$attributeName);
$attributeWithName = $attributeName[1];
}
my $attribute = $configTree->getAttributeByName($attributeWithName);
$attributeList->addOrderByAttribute($attribute);
}
}
my $exportables = $dataSet->get('exportables');
$exportables->{$attributeList->linkName()}->{$interface} = $attributeList;
$dataSet->set('exportables', $exportables);
}
else
{
next EXP;
}
}
# fix displayType etc for push action referenced filters - should be list
foreach my $fpage (@{$configTree->getAllFilterTrees}){
foreach my $fgroup (@{$fpage->getAllFilterGroups}){
foreach my $fcollection(@{$fgroup->getAllCollections}){
foreach my $filter(@{$fcollection->getAllFilters}){
my $options = $filter->getAllOptions;
next if (!$$options[0]);
my $push_actions = $$options[0]->getAllPushActions;
next if (!$push_actions);
foreach my $push_action(@{$push_actions}){
my $filter_to_fix =
$configTree->getFilterByName($push_action->ref);
if ($filter_to_fix) {
$filter_to_fix->displayType('list');
$filter_to_fix->style('menu');
}
}
}
}
}
}
return $configTree;
}
1;
# vim: et
]]>