subjectid handled by RestClientWrapper

8 files changed, 118 insertions, 119 deletions

diff --git a/lib/algorithm.rb b/lib/algorithm.rb
index a725141..036d345 100644
--- a/lib/algorithm.rb
+++ b/lib/algorithm.rb
@@ -9,7 +9,7 @@ module OpenTox
     # @param [optional,Boolean] wait  set to false if method should return a task uri instead of the algorithm result
     # @return [String] URI of new resource (dataset, model, ...)
     def run params=nil, wait=true
-      uri = RestClientWrapper.post @uri, params, { :content_type => "text/uri-list", :subjectid => SUBJECTID}
+      uri = RestClientWrapper.post @uri, params, { :content_type => "text/uri-list"}
       wait_for_task uri if wait
     end
 
diff --git a/lib/dataset.rb b/lib/dataset.rb
index cb64406..4fad05b 100644
--- a/lib/dataset.rb
+++ b/lib/dataset.rb
@@ -7,8 +7,8 @@ module OpenTox
 
     attr_writer :features, :compounds, :data_entries
 
-    def initialize uri=nil, subjectid=SUBJECTID
-      super uri, subjectid
+    def initialize uri=nil
+      super uri
       @features = []
       @compounds = []
       @data_entries = []
@@ -21,9 +21,9 @@ module OpenTox
       if @metadata.empty? or force_update
         uri = File.join(@uri,"metadata")
         begin
-          parse_ntriples RestClientWrapper.get(uri,{},{:accept => "text/plain", :subjectid => @subjectid})
+          parse_ntriples RestClientWrapper.get(uri,{},{:accept => "text/plain"})
         rescue # fall back to rdfxml
-          parse_rdfxml RestClientWrapper.get(uri,{},{:accept => "application/rdf+xml", :subjectid => @subjectid})
+          parse_rdfxml RestClientWrapper.get(uri,{},{:accept => "application/rdf+xml"})
         end
         @metadata = @rdf.to_hash[RDF::URI.new(@uri)].inject({}) { |h, (predicate, values)| h[predicate] = values.collect{|v| v.to_s}; h }
       end
@@ -34,7 +34,7 @@ module OpenTox
     def features force_update=false
       if @features.empty? or force_update
         uri = File.join(@uri,"features")
-        uris = RestClientWrapper.get(uri,{},{:accept => "text/uri-list", :subjectid => @subjectid}).split("\n") # ordered datasets return ordered features
+        uris = RestClientWrapper.get(uri,{},{:accept => "text/uri-list"}).split("\n") # ordered datasets return ordered features
         @features = uris.collect{|uri| Feature.new(uri)}
       end
       @features
@@ -44,7 +44,7 @@ module OpenTox
     def compounds force_update=false
       if @compounds.empty? or force_update
         uri = File.join(@uri,"compounds")
-        uris = RestClientWrapper.get(uri,{},{:accept => "text/uri-list", :subjectid => @subjectid}).split("\n") # ordered datasets return ordered compounds
+        uris = RestClientWrapper.get(uri,{},{:accept => "text/uri-list"}).split("\n") # ordered datasets return ordered compounds
         @compounds = uris.collect{|uri| Compound.new(uri)}
       end
       @compounds
@@ -61,7 +61,7 @@ module OpenTox
                       <#{RDF::OT.value}> ?value .
           ?f          <#{RDF::OLO.index}> ?fidx.
           } ORDER BY ?fidx ?cidx"
-          RestClientWrapper.get(service_uri,{:query => sparql},{:accept => "text/uri-list", :subjectid => @subjectid}).split("\n").each do |row|
+          RestClientWrapper.get(service_uri,{:query => sparql},{:accept => "text/uri-list"}).split("\n").each do |row|
             r,c,v = row.split("\t")
             @data_entries[r.to_i] ||= []
             # adjust value class depending on feature type, StringFeature takes precedence over NumericFeature
@@ -135,7 +135,7 @@ module OpenTox
     # @param filename [String]
     # @return [String] dataset uri
     def upload filename, wait=true
-      uri = RestClientWrapper.put(@uri, {:file => File.new(filename)}, {:subjectid => @subjectid})
+      uri = RestClientWrapper.put(@uri, {:file => File.new(filename)})
       wait_for_task uri if URI.task?(uri) and wait
       compounds true
       features true
diff --git a/lib/opentox-client.rb b/lib/opentox-client.rb
index 77c6eae..8683d0f 100644
--- a/lib/opentox-client.rb
+++ b/lib/opentox-client.rb
@@ -50,6 +50,13 @@ FALSE_REGEXP = /^(false|inactive|0|0.0|low tox|deactivating|non-carcinogen|non-m
   "validation.rb"
 ].each{ |f| require_relative f }
 
+if defined?($aa) and $aa[:uri] 
+  OpenTox::RestClientWrapper.subjectid = OpenTox::Authorization.authenticate($aa[:user],$aa[:password])
+  unauthorized_error "Failed to authenticate user \"#{$aa[:user]}\"." unless OpenTox::Authorization.is_token_valid(OpenTox::RestClientWrapper.subjectid)
+#else
+  #@@subjectid = nil
+end
+=begin
 module OpenTox
   if defined?($aa) and $aa[:uri] 
     SUBJECTID = OpenTox::Authorization.authenticate($aa[:user],$aa[:password])
@@ -58,4 +65,5 @@ module OpenTox
     SUBJECTID = nil
   end
 end
+=end
 
diff --git a/lib/opentox.rb b/lib/opentox.rb
index 73a33d3..87b241a 100644
--- a/lib/opentox.rb
+++ b/lib/opentox.rb
@@ -5,7 +5,7 @@ $logger.level = Logger::DEBUG
 module OpenTox
   #include RDF CH: leads to namespace clashes with URI class
 
-  attr_reader :uri, :subjectid
+  attr_reader :uri
   attr_writer :metadata, :parameters
 
   # Ruby interface
@@ -13,7 +13,7 @@ module OpenTox
   # Create a new OpenTox object 
   # @param uri [optional,String] URI
   # @return [OpenTox] OpenTox object
-  def initialize uri=nil, subjectid=SUBJECTID
+  def initialize uri=nil
     @rdf = RDF::Graph.new
     @metadata = {}
     @parameters = []
@@ -79,10 +79,10 @@ module OpenTox
   # @param [String,optional] mime_type
   def get mime_type="text/plain"
     bad_request_error "Mime type #{mime_type} is not supported. Please use 'text/plain' (default) or 'application/rdf+xml'." unless mime_type == "text/plain" or mime_type == "application/rdf+xml"
-    response = RestClientWrapper.get(@uri,{},{:accept => mime_type,:subjectid => @subjectid})
+    response = RestClientWrapper.get(@uri,{},{:accept => mime_type})
     if URI.task?(response)
       uri = wait_for_task response
-      response = RestClientWrapper.get(uri,{},{:accept => mime_type,:subjectid => @subjectid})
+      response = RestClientWrapper.get(uri,{},{:accept => mime_type})
     end
     parse_ntriples response if mime_type == "text/plain"
     parse_rdfxml response if mime_type == "application/rdf+xml"
@@ -98,8 +98,8 @@ module OpenTox
     when 'application/rdf+xml'
       body = self.to_rdfxml
     end
-    Authorization.check_policy(@uri, SUBJECTID) if $aa[:uri]
-    uri = RestClientWrapper.post @uri.to_s, body, { :content_type => mime_type,:subjectid => @subjectid}
+    Authorization.check_policy(@uri, RestClientWrapper.subjectid) if $aa[:uri]
+    uri = RestClientWrapper.post @uri.to_s, body, { :content_type => mime_type}
     wait ? wait_for_task(uri) : uri
   end
 
@@ -114,14 +114,14 @@ module OpenTox
     when 'application/rdf+xml'
       body = self.to_rdfxml
     end
-    uri = RestClientWrapper.put @uri.to_s, body, { :content_type => mime_type,:subjectid => @subjectid}
+    uri = RestClientWrapper.put @uri, body, { :content_type => mime_type}
     wait ? wait_for_task(uri) : uri
   end
 
   # Delete object at webservice
   def delete 
-    RestClientWrapper.delete(@uri.to_s,{},{:subjectid => @subjectid})
-    Authorization.delete_policies_from_uri(@uri, SUBJECTID) if $aa[:uri]
+    RestClientWrapper.delete(@uri)
+    Authorization.delete_policies_from_uri(@uri, RestClientWrapper.subjectid) if $aa[:uri]
   end
 
   def service_uri
@@ -200,6 +200,12 @@ module OpenTox
     rescue
       bad_request_error "$#{service}[:uri] variable not set. Please set $#{service}[:uri] or use an explicit uri as first constructor argument "
     end
+    def subjectid
+      RestClientWrapper.subjectid
+    end
+    def subjectid=(subjectid)
+      RestClientWrapper.subjectid = subjectid
+    end
   end
 
   # create default OpenTox classes with class methods
@@ -209,24 +215,24 @@ module OpenTox
       include OpenTox
 
       def self.all 
-        uris = RestClientWrapper.get(service_uri, {},{:accept => 'text/uri-list',:subjectid=>@subjectid}).split("\n").compact
+        uris = RestClientWrapper.get(service_uri, {},{:accept => 'text/uri-list'}).split("\n").compact
         uris.collect{|uri| self.new(uri)}
       end
 
       #@example fetching a model
       #  OpenTox::Model.find(<model-uri>) -> model-object
-      def self.find uri, subjectid=SUBJECTID
+      def self.find uri
         URI.accessible?(uri) ? self.new(uri) : nil
       end
 
-      def self.create metadata, subjectid=SUBJECTID
-        object = self.new nil, subjectid
+      def self.create metadata
+        object = self.new 
         object.metadata = metadata
         object.put
         object
       end
 
-      def self.find_or_create metadata, subjectid=SUBJECTID
+      def self.find_or_create metadata
         sparql = "SELECT DISTINCT ?s WHERE { "
         metadata.each do |predicate,objects|
           unless [RDF::DC.date,RDF::DC.modified,RDF::DC.description].include? predicate # remove dates and description (strange characters in description may lead to SPARQL errors)
@@ -242,11 +248,11 @@ module OpenTox
           end
         end
         sparql <<  "}"
-        uris = RestClientWrapper.get(service_uri,{:query => sparql},{:accept => "text/uri-list",:subjectid=>subjectid}).split("\n")
+        uris = RestClientWrapper.get(service_uri,{:query => sparql},{:accept => "text/uri-list"}).split("\n")
         if uris.empty?
-          self.create metadata, subjectid
+          self.create metadata
         else
-          self.new uris.first, subjectid
+          self.new uris.first
         end
       end
     end
diff --git a/lib/overwrite.rb b/lib/overwrite.rb
index c6bf02a..ff43347 100644
--- a/lib/overwrite.rb
+++ b/lib/overwrite.rb
@@ -84,21 +84,21 @@ module URI
     uri =~ /task/ and URI.valid? uri
   end
 
-  def self.dataset? uri, subjectid=OpenTox::SUBJECTID
-    uri =~ /dataset/ and URI.accessible? uri, subjectid
+  def self.dataset? uri
+    uri =~ /dataset/ and URI.accessible? uri
   end
 
-  def self.model? uri, subjectid=OpenTox::SUBJECTID
-    uri =~ /model/ and URI.accessible? uri, subjectid
+  def self.model? uri
+    uri =~ /model/ and URI.accessible? uri
   end
 
-  def self.ssl? uri, subjectid=OpenTox::SUBJECTID
+  def self.ssl? uri
     URI.parse(uri).instance_of? URI::HTTPS
   end
 
   # @return [Boolean] checks if resource exists by making a HEAD-request
-  def self.accessible?(uri, subjectid=OpenTox::SUBJECTID)
-    parsed_uri = URI.parse(uri + (subjectid ? "?subjectid=#{CGI.escape subjectid}" : ""))
+  def self.accessible?(uri)
+    parsed_uri = URI.parse(uri + (OpenTox::RestClientWrapper.subjectid ? "?subjectid=#{CGI.escape OpenTox::RestClientWrapper.subjectid}" : ""))
     http_code = URI.task?(uri) ? 600 : 400
     http = Net::HTTP.new(parsed_uri.host, parsed_uri.port)
     unless (URI.ssl? uri) == true
diff --git a/lib/rest-client-wrapper.rb b/lib/rest-client-wrapper.rb
index 2de9377..134dd32 100644
--- a/lib/rest-client-wrapper.rb
+++ b/lib/rest-client-wrapper.rb
@@ -4,6 +4,16 @@ module OpenTox
     
     attr_accessor :request, :response
 
+    @@subjectid = nil
+
+    def self.subjectid=(subjectid)
+      @@subjectid = subjectid
+    end
+
+    def self.subjectid
+      @@subjectid
+    end
+
     # REST methods 
     # Raises OpenTox::Error if call fails (rescued in overwrite.rb -> halt 502)
     # Does not wait for task to finish and returns task uri
@@ -17,7 +27,7 @@ module OpenTox
 
         # check input
         bad_request_error "Headers are not a hash: #{headers.inspect}", uri unless headers==nil or headers.is_a?(Hash) 
-        headers[:subjectid] ||= OpenTox::SUBJECTID
+        headers[:subjectid] ||= @@subjectid
         bad_request_error "Invalid URI: '#{uri}'", uri unless URI.valid? uri
         #resource_not_found_error "URI '#{uri}' not found.", uri unless URI.accessible?(uri, @subjectid) unless URI.ssl?(uri)
         # make sure that no header parameters are set in the payload
diff --git a/lib/task.rb b/lib/task.rb
index d642f48..07efc0f 100644
--- a/lib/task.rb
+++ b/lib/task.rb
@@ -10,9 +10,9 @@ module OpenTox
       super true # always update metadata
     end
 
-    def self.run(description, creator=nil, subjectid=SUBJECTID)
+    def self.run(description, creator=nil)
 
-      task = Task.new nil, subjectid
+      task = Task.new nil
       task[RDF::OT.created_at] = DateTime.now
       task[RDF::OT.hasStatus] = "Running"
       task[RDF::DC.description] = description.to_s
@@ -23,7 +23,7 @@ module OpenTox
           task.completed yield
         rescue
           if $!.respond_to? :to_ntriples
-            RestClientWrapper.put(File.join(task.uri,'Error'),{:errorReport => $!.to_ntriples},{:content_type => 'text/plain', :subjectid => task.subjectid}) 
+            RestClientWrapper.put(File.join(task.uri,'Error'),{:errorReport => $!.to_ntriples},{:content_type => 'text/plain'}) 
           else
             cut_index = $!.backtrace.find_index{|line| line.match /gems\/sinatra/}
             cut_index = -1 unless cut_index
@@ -41,7 +41,7 @@ module OpenTox
             nt = RDF::Writer.for(:ntriples).buffer do |writer|
               @rdf.each{|statement| writer << statement}
             end
-            RestClientWrapper.put(File.join(task.uri,'Error'),{:errorReport => nt},{:content_type => 'text/plain', :subjectid => task.subjectid}) 
+            RestClientWrapper.put(File.join(task.uri,'Error'),{:errorReport => nt},{:content_type => 'text/plain'}) 
           end
           task.kill
         end
@@ -107,7 +107,7 @@ module OpenTox
   end
 
   def code
-    RestClientWrapper.head(@uri,{},:subjectid => @subjectid).code.to_i
+    RestClientWrapper.head(@uri).code.to_i
   end
 
   # get only header for status requests
diff --git a/lib/validation.rb b/lib/validation.rb
index 565a366..997f814 100644
--- a/lib/validation.rb
+++ b/lib/validation.rb
@@ -9,13 +9,13 @@ module OldOpenTox
   end
 
   # loads metadata via yaml
-  def load_metadata( subjectid=nil )
-    yaml = OpenTox::RestClientWrapper.get(uri,nil,{:subjectid => subjectid, :accept => "application/x-yaml"})
+  def load_metadata
+    yaml = OpenTox::RestClientWrapper.get(uri,nil,{:accept => "application/x-yaml"})
     @metadata = YAML.load(yaml)
   end
 
-  def delete (subjectid=nil)
-    OpenTox::RestClientWrapper.delete(@uri.to_s,nil,{:subjectid => subjectid})
+  def delete 
+    OpenTox::RestClientWrapper.delete @uri.to_s
   end
 end
 
@@ -26,80 +26,71 @@ module OpenTox
 
     # find validation, raises error if not found
     # @param [String] uri
-    # @param [String,optional] subjectid
     # @return [OpenTox::Validation]
-    def self.find( uri, subjectid=nil )
+    def self.find( uri )
       val = Validation.new(uri)
-      val.load_metadata( subjectid )
+      val.load_metadata
       val
     end
 
     # returns a filtered list of validation uris
     # @param params [Hash,optional] validation-params to filter the uris (could be model, training_dataset, ..)
     # @return [Array]
-    def self.list( params={}, subjectid=nil )
+    def self.list( params={} )
       filter_string = ""
       params.each do |k,v|
         filter_string += (filter_string.length==0 ? "?" : "&")
         v = v.to_s.gsub(/;/, "%3b") if v.to_s =~ /;/
         filter_string += k.to_s+"="+v.to_s
       end
-      (OpenTox::RestClientWrapper.get($validation[:uri]+filter_string,nil,{:subjectid => subjectid}).split("\n"))
+      (OpenTox::RestClientWrapper.get($validation[:uri]+filter_string).split("\n"))
     end
 
     # creates a training test split validation, waits until it finishes, may take some time
     # @param [Hash] params (required:algorithm_uri,dataset_uri,prediction_feature, optional:algorithm_params,split_ratio(0.67),random_seed(1))
-    # @param [String,optional] subjectid
     # @param [OpenTox::Task,optional] waiting_task (can be a OpenTox::Subtask as well), progress is updated accordingly
     # @return [OpenTox::Validation]
-    def self.create_training_test_split( params, subjectid=nil, waiting_task=nil )
-      #params[:subjectid] = subjectid if subjectid
+    def self.create_training_test_split( params, waiting_task=nil )
       uri = OpenTox::RestClientWrapper.post( File.join($validation[:uri],"training_test_split"),
-        params,{:content_type => "text/uri-list", :subjectid => subjectid},waiting_task )
+        params,{:content_type => "text/uri-list"},waiting_task )
       Validation.new(wait_for_task(uri))
     end
 
     # creates a training test validation, waits until it finishes, may take some time
     # @param [Hash] params (required:algorithm_uri,training_dataset_uri,prediction_feature,test_dataset_uri,optional:algorithm_params)
-    # @param [String,optional] subjectid
     # @param [OpenTox::Task,optional] waiting_task (can be a OpenTox::Subtask as well), progress is updated accordingly
     # @return [OpenTox::Validation]
-    def self.create_training_test_validation( params, subjectid=nil, waiting_task=nil )
-      params[:subjectid] = subjectid if subjectid
+    def self.create_training_test_validation( params, waiting_task=nil )
       uri = OpenTox::RestClientWrapper.post( File.join($validation[:uri],"training_test_validation"),
-        params,{:content_type => "text/uri-list", :subjectid => subjectid},waiting_task )
+        params,{:content_type => "text/uri-list"},waiting_task )
       Validation.new(wait_for_task(uri))
     end
 
     # creates a bootstrapping validation, waits until it finishes, may take some time
     # @param [Hash] params (required:algorithm_uri,dataset_uri,prediction_feature, optional:algorithm_params,random_seed(1))
-    # @param [String,optional] subjectid
     # @param [OpenTox::Task,optional] waiting_task (can be a OpenTox::Subtask as well), progress is updated accordingly
     # @return [OpenTox::Validation]
-    def self.create_bootstrapping_validation( params, subjectid=nil, waiting_task=nil )
-      params[:subjectid] = subjectid if subjectid
+    def self.create_bootstrapping_validation( params, waiting_task=nil )
       uri = OpenTox::RestClientWrapper.post( File.join($validation[:uri],"bootstrapping"),
-        params,{:content_type => "text/uri-list", :subjectid => subjectid},waiting_task )
+        params,{:content_type => "text/uri-list"},waiting_task )
       Validation.new(wait_for_task(uri))
     end
 
     # looks for report for this validation, creates a report if no report is found
-    # @param [String,optional] subjectid
     # @param [OpenTox::Task,optional] waiting_task (can be a OpenTox::Subtask as well), progress is updated accordingly
     # @return [String] report uri
-    def find_or_create_report( subjectid=nil, waiting_task=nil )
-      @report = ValidationReport.find_for_validation(@uri, subjectid) unless @report
-      @report = ValidationReport.create(@uri, {}, subjectid, waiting_task) unless @report
+    def find_or_create_report( waiting_task=nil )
+      @report = ValidationReport.find_for_validation(@uri) unless @report
+      @report = ValidationReport.create(@uri, waiting_task) unless @report
       @report.uri
     end
 
     # creates a validation object from crossvaldiation statistics, raise error if not found
     # (as crossvaldiation statistics are returned as an average valdidation over all folds)
     # @param crossvalidation_uri [String] crossvalidation uri
-    # @param [String,optional] subjectid
     # @return [OpenTox::Validation]
-    def self.from_cv_statistics( crossvalidation_uri, subjectid=nil )
-      find( File.join(crossvalidation_uri, 'statistics'),subjectid )
+    def self.from_cv_statistics( crossvalidation_uri )
+      find( File.join(crossvalidation_uri, 'statistics') )
     end
 
     # returns confusion matrix as array, predicted values are in rows
@@ -131,7 +122,6 @@ module OpenTox
     #
     # @param confidence [Float] confidence value (between 0 and 1)
     # @param prediction [String] predicted value
-    # @param subjectid [String,optional]
     # @return [Hash] see example
     # @example
     #  Example 1:
@@ -145,9 +135,9 @@ module OpenTox
     #  the given confidence value was to high (i.e. <12 predictions with confidence value >= 0.8)
     #  the top 12 "active" predictions have a min_confidence of 0.45, 90 percent of them beeing correct
     #
-    def probabilities( confidence, prediction, subjectid=nil )
+    def probabilities( confidence, prediction )
       YAML.load(OpenTox::RestClientWrapper.get(@uri+"/probabilities?prediction="+prediction.to_s+"&confidence="+confidence.to_s,nil,
-        {:subjectid => subjectid, :accept => "application/x-yaml"}))
+        {:accept => "application/x-yaml"}))
     end
   end
 
@@ -158,11 +148,10 @@ module OpenTox
 
     # find crossvalidation, raises error if not found
     # @param [String] uri
-    # @param [String,optional] subjectid
     # @return [OpenTox::Crossvalidation]
-    def self.find( uri, subjectid=nil )
+    def self.find( uri )
       cv = Crossvalidation.new(uri)
-      cv.load_metadata( subjectid )
+      cv.load_metadata
       cv
     end
 
@@ -181,42 +170,39 @@ module OpenTox
 		
     # creates a crossvalidations, waits until it finishes, may take some time
     # @param [Hash] params (required:algorithm_uri,dataset_uri,prediction_feature, optional:algorithm_params,num_folds(10),random_seed(1),stratified(false))
-    # @param [String,optional] subjectid
     # @param [OpenTox::Task,optional] waiting_task (can be a OpenTox::Subtask as well), progress is updated accordingly
     # @return [OpenTox::Crossvalidation]
-    def self.create( params, subjectid=nil, waiting_task=nil )
-      #params[:subjectid] = subjectid if subjectid
+    def self.create( params, waiting_task=nil )
       uri = OpenTox::RestClientWrapper.post( File.join($validation[:uri],"crossvalidation"),
-        params,{:content_type => "text/uri-list", :subjectid => subjectid},waiting_task )
+        params,{:content_type => "text/uri-list"},waiting_task )
       uri = wait_for_task(uri)
       Crossvalidation.new(uri)
     end
 
     # looks for report for this crossvalidation, creates a report if no report is found
-    # @param [String,optional] subjectid
     # @param [OpenTox::Task,optional] waiting_task (can be a OpenTox::Subtask as well), progress is updated accordingly
     # @return [String] report uri
-    def find_or_create_report( subjectid=nil, waiting_task=nil )
-      @report = CrossvalidationReport.find_for_crossvalidation(@uri, subjectid) unless @report
-      @report = CrossvalidationReport.create(@uri, subjectid, waiting_task) unless @report
+    def find_or_create_report( waiting_task=nil )
+      @report = CrossvalidationReport.find_for_crossvalidation(@uri) unless @report
+      @report = CrossvalidationReport.create(@uri, waiting_task) unless @report
       @report.uri
     end
 
     # loads metadata via yaml from crossvalidation object
     # fields (like for example the validations) can be acces via validation.metadata[RDF::OT.validation]
-    def load_metadata( subjectid=nil )
-      @metadata = YAML.load(OpenTox::RestClientWrapper.get(uri,nil,{:subjectid => subjectid, :accept => "application/x-yaml"}))
+    def load_metadata
+      @metadata = YAML.load(OpenTox::RestClientWrapper.get(uri,nil,{:accept => "application/x-yaml"}))
     end
 
     # returns a Validation object containing the statistics of the crossavlidation
-    def statistics( subjectid=nil )
-      Validation.from_cv_statistics( @uri, subjectid )
+    def statistics
+      Validation.from_cv_statistics( @uri )
     end
 
     # documentation see OpenTox::Validation.probabilities
-    def probabilities( confidence, prediction, subjectid=nil )
+    def probabilities( confidence, prediction )
       YAML.load(OpenTox::RestClientWrapper.get(@uri+"/statistics/probabilities?prediction="+prediction.to_s+"&confidence="+confidence.to_s,nil,
-        {:subjectid => subjectid, :accept => "application/x-yaml"}))
+        {:accept => "application/x-yaml"}))
     end
 
   end
@@ -226,22 +212,20 @@ module OpenTox
 
     # finds ValidationReport via uri, raises error if not found
     # @param [String] uri
-    # @param [String,optional] subjectid
     # @return [OpenTox::ValidationReport]
-    def self.find( uri, subjectid=nil )
-      OpenTox::RestClientWrapper.get(uri,nil,{:subjectid => subjectid})
+    def self.find( uri )
+      OpenTox::RestClientWrapper.get(uri)
       rep = ValidationReport.new(uri)
-      rep.load_metadata( subjectid )
+      rep.load_metadata
       rep
     end
 
     # finds ValidationReport for a particular validation
     # @param validation_uri [String] crossvalidation uri
-    # @param subjectid [String,optional]
     # @return [OpenTox::ValidationReport] nil if no report found
-    def self.find_for_validation( validation_uri, subjectid=nil )
+    def self.find_for_validation( validation_uri )
       uris = RestClientWrapper.get(File.join($validation[:uri],
-        "/report/validation?validation="+validation_uri),nil,{:subjectid => subjectid}).chomp.split("\n")
+        "/report/validation?validation="+validation_uri)).chomp.split("\n")
       uris.size==0 ? nil : ValidationReport.new(uris[-1])
     end
 
@@ -249,16 +233,14 @@ module OpenTox
     # @param validation_uri [String] validation uri
     # @param params [Hash] params addiditonal possible
     #               (min_confidence, params={}, min_num_predictions, max_num_predictions)
-    # @param subjectid [String,optional]
     # @param waiting_task [OpenTox::Task,optional] (can be a OpenTox::Subtask as well), progress is updated accordingly
     # @return [OpenTox::ValidationReport]
-    def self.create( validation_uri, params={}, subjectid=nil, waiting_task=nil )
+    def self.create( validation_uri, params={}, waiting_task=nil )
       params = {} if params==nil
       bad_request_error "params is no hash" unless params.is_a?(Hash)
       params[:validation_uris] = validation_uri
-      params[:subjectid] = subjectid
       uri = RestClientWrapper.post(File.join($validation[:uri],"/report/validation"),
-        params, {:subjectid => subjectid}, waiting_task )
+        params, {}, waiting_task )
       uri = wait_for_task(uri)
       ValidationReport.new(uri)
     end
@@ -270,33 +252,30 @@ module OpenTox
 
     # finds CrossvalidationReport via uri, raises error if not found
     # @param [String] uri
-    # @param [String,optional] subjectid
     # @return [OpenTox::CrossvalidationReport]
-    def self.find( uri, subjectid=nil )
-      OpenTox::RestClientWrapper.get(uri,nil,{:subjectid => subjectid})
+    def self.find( uri )
+      OpenTox::RestClientWrapper.get(uri)
       rep = CrossvalidationReport.new(uri)
-      rep.load_metadata( subjectid )
+      rep.load_metadata
       rep
     end
 
     # finds CrossvalidationReport for a particular crossvalidation
     # @param crossvalidation_uri [String] crossvalidation uri
-    # @param subjectid [String,optional]
     # @return [OpenTox::CrossvalidationReport] nil if no report found
-    def self.find_for_crossvalidation( crossvalidation_uri, subjectid=nil )
+    def self.find_for_crossvalidation( crossvalidation_uri )
       uris = RestClientWrapper.get(File.join($validation[:uri],
-        "/report/crossvalidation?crossvalidation="+crossvalidation_uri),nil,{:subjectid => subjectid}).chomp.split("\n")
+        "/report/crossvalidation?crossvalidation="+crossvalidation_uri)).chomp.split("\n")
       uris.size==0 ? nil : CrossvalidationReport.new(uris[-1])
     end
 
     # creates a crossvalidation report via crossvalidation
     # @param crossvalidation_uri [String] crossvalidation uri
-    # @param subjectid [String,optional]
     # @param waiting_task [OpenTox::Task,optional] (can be a OpenTox::Subtask as well), progress is updated accordingly
     # @return [OpenTox::CrossvalidationReport]
-    def self.create( crossvalidation_uri, subjectid=nil, waiting_task=nil )
+    def self.create( crossvalidation_uri, waiting_task=nil )
       uri = RestClientWrapper.post(File.join($validation[:uri],"/report/crossvalidation"),
-        { :validation_uris => crossvalidation_uri, :subjectid => subjectid }, {}, waiting_task )
+        { :validation_uris => crossvalidation_uri }, {}, waiting_task )
       uri = wait_for_task(uri)
       CrossvalidationReport.new(uri)
     end
@@ -308,22 +287,20 @@ module OpenTox
 
     # finds AlgorithmComparisonReport via uri, raises error if not found
     # @param [String] uri
-    # @param [String,optional] subjectid
     # @return [OpenTox::CrossvalidationReport]
-    def self.find( uri, subjectid=nil )
-      OpenTox::RestClientWrapper.get(uri,nil,{:subjectid => subjectid})
+    def self.find( uri )
+      OpenTox::RestClientWrapper.get(uri)
       rep = AlgorithmComparisonReport.new(uri)
-      rep.load_metadata( subjectid )
+      rep.load_metadata
       rep
     end
 
     # finds AlgorithmComparisonReport for a particular crossvalidation
     # @param crossvalidation_uri [String] crossvalidation uri
-    # @param subjectid [String,optional]
     # @return [OpenTox::AlgorithmComparisonReport] nil if no report found
-    def self.find_for_crossvalidation( crossvalidation_uri, subjectid=nil )
+    def self.find_for_crossvalidation( crossvalidation_uri )
       uris = RestClientWrapper.get(File.join($validation[:uri],
-        "/report/algorithm_comparison?crossvalidation="+crossvalidation_uri),nil,{:subjectid => subjectid}).chomp.split("\n")
+        "/report/algorithm_comparison?crossvalidation="+crossvalidation_uri)).chomp.split("\n")
       uris.size==0 ? nil : AlgorithmComparisonReport.new(uris[-1])
     end
 
@@ -331,13 +308,12 @@ module OpenTox
     # @param crossvalidation_uri_hash [Hash] crossvalidation uri_hash, see example
     # @param params [Hash] params addiditonal possible
     #               (ttest_significance, ttest_attributes, min_confidence, min_num_predictions, max_num_predictions)
-    # @param subjectid [String,optional]
     # @param waiting_task [OpenTox::Task,optional] (can be a OpenTox::Subtask as well), progress is updated accordingly
     # @return [OpenTox::AlgorithmComparisonReport]
     # example for hash:
     # { :lazar-bbrc => [ http://host/validation/crossvalidation/x1, http://host/validation/crossvalidation/x2 ],
     #   :lazar-last => [ http://host/validation/crossvalidation/xy, http://host/validation/crossvalidation/xy ] }
-    def self.create( crossvalidation_uri_hash, params={}, subjectid=nil, waiting_task=nil )
+    def self.create( crossvalidation_uri_hash, params={}, waiting_task=nil )
       identifier = []
       validation_uris = []
       crossvalidation_uri_hash.each do |id, uris|
@@ -350,8 +326,7 @@ module OpenTox
       raise OpenTox::BadRequestError.new "params is no hash" unless params.is_a?(Hash)
       params[:validation_uris] = validation_uris.join(",")
       params[:identifier] = identifier.join(",")
-      params[:subjectid] = subjectid
-      uri = RestClientWrapper.post(File.join($validation[:uri],"/report/algorithm_comparison"), params, {:subjectid => subjectid}, waiting_task )
+      uri = RestClientWrapper.post(File.join($validation[:uri],"/report/algorithm_comparison"), params, waiting_task )
       uri = wait_for_task(uri)
       AlgorithmComparisonReport.new(uri)
     end