subjectid handled by RestClientWrapper

14 files changed, 172 insertions, 204 deletions

diff --git a/lib/dataset_cache.rb b/lib/dataset_cache.rb
index 1af1d51..ff2de3f 100644
--- a/lib/dataset_cache.rb
+++ b/lib/dataset_cache.rb
@@ -8,16 +8,16 @@ module Lib
     # same as OpenTox::Dataset.find with caching function
     # rational: datasets are reused in crossvalidation very often, cache to save computational effort
     # PENDING: may cause memory issues, test with huge datasets 
-    def self.find(dataset_uri, subjectid=nil)
+    def self.find(dataset_uri)
       return nil if (dataset_uri==nil)
-      d = @@cache[dataset_uri.to_s+"_"+subjectid.to_s]
+      d = @@cache[dataset_uri.to_s+"_"+OpenTox::RestClientWrapper.subjectid.to_s]
       if d==nil
-        d = OpenTox::Dataset.find(dataset_uri, subjectid)
-        @@cache[dataset_uri.to_s+"_"+subjectid.to_s] = d
+        d = OpenTox::Dataset.find(dataset_uri)
+        @@cache[dataset_uri.to_s+"_"+OpenTox::RestClientWrapper.subjectid.to_s] = d
       end
       d
     end
     
   end
   
-end
\ No newline at end of file
+end
diff --git a/lib/prediction_data.rb b/lib/prediction_data.rb
index 833ebe0..9450a5b 100644
--- a/lib/prediction_data.rb
+++ b/lib/prediction_data.rb
@@ -55,7 +55,7 @@ module Lib
     end
     
     def self.create( feature_type, test_dataset_uris, prediction_feature, prediction_dataset_uris, 
-      predicted_variables, predicted_confidences, subjectid=nil, task=nil )      
+      predicted_variables, predicted_confidences, task=nil )      
       
       test_dataset_uris = [test_dataset_uris] unless test_dataset_uris.is_a?(Array)
       prediction_dataset_uris = [prediction_dataset_uris] unless prediction_dataset_uris.is_a?(Array)
@@ -88,7 +88,7 @@ module Lib
         
         predicted_variable=prediction_feature if predicted_variable==nil
       
-        test_dataset = Lib::DatasetCache.find test_dataset_uri,subjectid
+        test_dataset = Lib::DatasetCache.find test_dataset_uri
         internal_server_error "test dataset not found: '"+test_dataset_uri.to_s+"'" unless test_dataset
       
         internal_server_error "prediction_feature not found in test_dataset\n"+
@@ -122,7 +122,7 @@ module Lib
         end
         task.progress( task_status += task_step ) if task # loaded actual values
       
-        prediction_dataset = Lib::DatasetCache.find prediction_dataset_uri,subjectid
+        prediction_dataset = Lib::DatasetCache.find prediction_dataset_uri
         internal_server_error "prediction dataset not found: '"+prediction_dataset_uri.to_s+"'" unless prediction_dataset
         
         # allow missing prediction feature if there are no compounds in the prediction dataset
diff --git a/lib/validation_db.rb b/lib/validation_db.rb
index 3725b51..ecc0693 100755
--- a/lib/validation_db.rb
+++ b/lib/validation_db.rb
@@ -87,8 +87,6 @@ module Validation
     index :training_dataset_uri
     index :test_dataset_uri
     
-    attr_accessor :subjectid
-    
     def self.create(params={})
       Ohm.connect(:thread_safe => true, :port => 6379)
       params[:date] = Time.new
@@ -121,7 +119,7 @@ module Validation
 
     def save
       super
-      OpenTox::Authorization.check_policy(validation_uri, subjectid)
+      OpenTox::Authorization.check_policy(validation_uri, OpenTox::RestClientWrapper.subjectid)
     end
     
     public
@@ -161,8 +159,6 @@ module Validation
     attribute :stratified
     attribute :loo
     
-    attr_accessor :subjectid
-    
     index :algorithm_uri
     index :algorithm_params
     index :prediction_feature
@@ -181,7 +177,7 @@ module Validation
     
     def save
       super
-      OpenTox::Authorization.check_policy(crossvalidation_uri, subjectid)
+      OpenTox::Authorization.check_policy(crossvalidation_uri, OpenTox::RestClientWrapper.subjectid)
     end
     
     public
@@ -193,12 +189,12 @@ module Validation
     # convenience method to list all crossvalidations that are unique 
     # in terms of dataset_uri,num_folds,stratified,random_seed
     # further conditions can be specified in __conditions__
-    def self.find_all_uniq(conditions={}, subjectid=nil )
+    def self.find_all_uniq(conditions={} )
       #cvs = Lib::Crossvalidation.find(:all, :conditions => conditions)
       cvs = Crossvalidation.find( conditions )
       uniq = []
       cvs.each do |cv|
-        next if $aa[:uri] and !OpenTox::Authorization.authorized?(cv.crossvalidation_uri,"GET",subjectid)
+        next if $aa[:uri] and !OpenTox::Authorization.authorized?(cv.crossvalidation_uri,"GET",OpenTox::RestClientWrapper.subjectid)
         match = false
         uniq.each do |cv2|
           if cv.dataset_uri == cv2.dataset_uri and cv.num_folds == cv2.num_folds and 
diff --git a/report/plot_factory.rb b/report/plot_factory.rb
index 1f35437..fa8f370 100644
--- a/report/plot_factory.rb
+++ b/report/plot_factory.rb
@@ -108,7 +108,7 @@ module Reports
         validation_set.validations.each do |v|
         [[v.test_dataset_uri, test],
          [v.training_dataset_uri, train]].each do |uri,array|
-            d = Lib::DatasetCache.find(uri, validation_set.validations[0].subjectid)
+            d = Lib::DatasetCache.find(uri)
             d.compounds.each do |c|
               d.data_entries[c][v.prediction_feature].each do |val|
                 array << val 
@@ -124,7 +124,7 @@ module Reports
       else
         Reports::r_util.feature_value_plot(out_files, validation_set.validations[0].training_feature_dataset_uri,
           validation_set.validations[0].test_feature_dataset_uri, "Training Data", "Test Data",
-          nil, validation_set.validations[0].subjectid, waiting_task )
+          nil, waiting_task )
       end
     end
     
diff --git a/report/report_application.rb b/report/report_application.rb
index a4d3d1f..437fa0b 100755
--- a/report/report_application.rb
+++ b/report/report_application.rb
@@ -137,7 +137,7 @@ class Validation::Application < OpenTox::Service
   delete '/validation/report/:type/:id' do
     perform do |rs|
       content_type "text/plain"
-      rs.delete_report(params[:type],params[:id],@subjectid)
+      rs.delete_report(params[:type],params[:id])
     end
   end
   
@@ -147,7 +147,7 @@ class Validation::Application < OpenTox::Service
       perform do |rs|
         puts rs.inspect
         rs.create_report(params[:type],params[:validation_uris]?params[:validation_uris].split(/\n|,/):nil,
-          params[:identifier]?params[:identifier].split(/\n|,/):nil,params,@subjectid,task)
+          params[:identifier]?params[:identifier].split(/\n|,/):nil,params,task)
       end
     end
     return_task(task)
diff --git a/report/report_persistance.rb b/report/report_persistance.rb
index a0f16d5..60fd454 100755
--- a/report/report_persistance.rb
+++ b/report/report_persistance.rb
@@ -52,7 +52,7 @@ class Reports::ReportPersistance
   # call-seq:
   #   delete_report(type, id) => boolean
   #
-  def delete_report(type, id, subjectid=nil)
+  def delete_report(type, id)
     internal_server_error "not implemented"
   end
   
@@ -104,7 +104,7 @@ class Reports::FileReportPersistance < Reports::ReportPersistance
     return file_path
   end
   
-  def delete_report(type, id, subjectid=nil)
+  def delete_report(type, id)
     
     report_dir = report_directory(type, id)
     raise_report_not_found(type, id) unless File.directory?(report_dir)
@@ -202,8 +202,6 @@ module Reports
     index :crossvalidation_uris
     index :algorithm_uris
     
-    attr_accessor :subjectid
-    
     def self.create(params={})
       params[:date] = Time.new
       super params
@@ -211,7 +209,7 @@ module Reports
     
     def save
       super
-      OpenTox::Authorization.check_policy(report_uri, subjectid)
+      OpenTox::Authorization.check_policy(report_uri, OpenTox::RestClientWrapper.subjectid)
     end
     
     def report_uri
@@ -241,12 +239,11 @@ module Reports
   
   class ExtendedFileReportPersistance < FileReportPersistance
     
-    def new_report(report_content, type, meta_data, uri_provider, subjectid=nil)
+    def new_report(report_content, type, meta_data, uri_provider)
       internal_server_error "report meta data missing" unless meta_data
       meta_data[:report_type] = type
       report = ReportData.create(meta_data)
-      report.subjectid = subjectid
-      OpenTox::Authorization.check_policy(report.report_uri, subjectid)
+      OpenTox::Authorization.check_policy(report.report_uri, OpenTox::RestClientWrapper.subjectid)
       new_report_with_id(report_content, type, report.id)
     end
     
@@ -278,7 +275,7 @@ module Reports
       end
     end
     
-    def delete_report(type, id, subjectid=nil)
+    def delete_report(type, id)
 #      begin
 #        report = ReportData.find(:first, :conditions => {:id => id, :report_type => type})
 #      rescue ActiveRecord::RecordNotFound
@@ -289,9 +286,9 @@ module Reports
       resource_not_found_error("Report with id='"+id.to_s+"' and type='"+type.to_s+"' not found.") if
         report==nil || report.report_type!=type
       report.delete
-      if (subjectid)
+      if (OpenTox::RestClientWrapper.subjectid)
         begin
-          res = OpenTox::Authorization.delete_policies_from_uri(report.report_uri, subjectid)
+          res = OpenTox::Authorization.delete_policies_from_uri(report.report_uri, OpenTox::RestClientWrapper.subjectid)
           $logger.debug "Deleted validation policy: #{res}"
         rescue
           $logger.warn "Policy delete error for validation: #{report.report_uri}"
diff --git a/report/report_service.rb b/report/report_service.rb
index 61f058c..0c3c647 100644
--- a/report/report_service.rb
+++ b/report/report_service.rb
@@ -60,7 +60,7 @@ module Reports
     # call-seq:
     #   create_report(type, validation_uris) => string
     # 
-    def create_report(type, validation_uris, identifier=nil, params={}, subjectid=nil, task=nil)
+    def create_report(type, validation_uris, identifier=nil, params={}, task=nil)
       
       internal_server_error "params is no hash" unless params.is_a?(Hash)
       $logger.info "create report of type '"+type.to_s+"'"
@@ -80,7 +80,7 @@ module Reports
           filter_params[key] = params[key].to_f
         end
       end
-      validation_set = Reports::ValidationSet.new(validation_uris, identifier, filter_params, subjectid)
+      validation_set = Reports::ValidationSet.new(validation_uris, identifier, filter_params)
       bad_request_error("cannot get validations from validation_uris '"+validation_uris.inspect+"'") unless validation_set and validation_set.size > 0
       $logger.debug "loaded "+validation_set.size.to_s+" validation/s"
       task.progress(10) if task
@@ -90,10 +90,10 @@ module Reports
         OpenTox::SubTask.create(task,10,90))
       $logger.debug "report created"
       Reports::quit_r
-      Reports.validation_access.delete_tmp_resources(subjectid)
+      Reports.validation_access.delete_tmp_resources
 
       #step 3: persist report if creation not failed
-      id = @@persistance.new_report(report_content, type, create_meta_data(type, validation_set, validation_uris), self, subjectid)
+      id = @@persistance.new_report(report_content, type, create_meta_data(type, validation_set, validation_uris), self)
       $logger.debug "report persisted with id: '"+id.to_s+"'"
       task.progress(100) if task
       
@@ -135,19 +135,19 @@ module Reports
     # call-seq:
     #   delete_report( type, id )
     # 
-    def delete_report( type, id, subjectid=nil )
+    def delete_report( type, id )
       
       $logger.info "delete report '"+id.to_s+"' of type '"+type.to_s+"'"
       check_report_type(type)
-      @@persistance.delete_report(type, id, subjectid)
+      @@persistance.delete_report(type, id)
     end
     
     # no api-access for this method
-    def delete_all_reports( type, subjectid=nil )
+    def delete_all_reports( type )
       
       $logger.info "deleting all reports of type '"+type.to_s+"'"
       check_report_type(type)
-      @@persistance.list_reports(type).each{ |id| @@persistance.delete_report(type, id, subjectid) }
+      @@persistance.list_reports(type).each{ |id| @@persistance.delete_report(type, id) }
     end
     
     def parse_type( report_uri )
diff --git a/report/validation_access.rb b/report/validation_access.rb
index a47dede..e9d1c64 100755
--- a/report/validation_access.rb
+++ b/report/validation_access.rb
@@ -15,7 +15,7 @@ class Reports::ValidationDB
     self_uri.host == val_uri.host && self_uri.port == val_uri.port
   end
   
-  def resolve_cv_uris(validation_uris, identifier, subjectid)
+  def resolve_cv_uris(validation_uris, identifier)
     res = {}
     count = 0
     validation_uris.each do |u|
@@ -27,7 +27,7 @@ class Reports::ValidationDB
         
         if same_service?u
           unauthorized_error "Not authorized: GET "+u.to_s if
-            $aa[:uri] and !OpenTox::Authorization.authorized?(u,"GET",subjectid)
+            $aa[:uri] and !OpenTox::Authorization.authorized?(u,"GET",OpenTox::RestClientWrapper.subjectid)
           Ohm.connect(:thread_safe => true, :port => 6379)
           cv = Validation::Crossvalidation[cv_id]
           resource_not_found_error "crossvalidation with id "+cv_id.to_s+" not found" unless cv
@@ -36,7 +36,7 @@ class Reports::ValidationDB
           val_uris = Validation::Validation.find( :crossvalidation_id => cv_id, :validation_type => "crossvalidation" ).collect{|v| v.validation_uri.to_s}
         else
           val_base_uri = u.gsub(/\/crossvalidation\/[0-9]+/,"")
-          val_uris = OpenTox::RestClientWrapper.get( val_base_uri+"?crossvalidation_id="+cv_id.to_s+"&validation_type=crossvalidation",nil,{:subjectid => subjectid, :accept => "text/uri-list" }).split("\n")
+          val_uris = OpenTox::RestClientWrapper.get( val_base_uri+"?crossvalidation_id="+cv_id.to_s+"&validation_type=crossvalidation",nil,{:accept => "text/uri-list" }).split("\n")
         end
         
         val_uris.each do |v_uri|
@@ -50,7 +50,7 @@ class Reports::ValidationDB
     res
   end
   
-  def init_validation(validation, uri, filter_params, subjectid)
+  def init_validation(validation, uri, filter_params)
     
     bad_request_error "not a validation uri: "+uri.to_s unless uri =~ /\/[0-9]+$/
     validation_id = uri.split("/")[-1]
@@ -61,13 +61,13 @@ class Reports::ValidationDB
     
     if same_service? uri
       unauthorized_error "Not authorized: GET "+uri.to_s if
-        $aa[:uri] and !OpenTox::Authorization.authorized?(uri,"GET",subjectid)
+        $aa[:uri] and !OpenTox::Authorization.authorized?(uri,"GET",OpenTox::RestClientWrapper.subjectid)
       Ohm.connect(:thread_safe => true, :port => 6379)
       v = Validation::Validation[validation_id]
     else
-      v = YAML::load(OpenTox::RestClientWrapper.get uri,nil,{:subjectid=>subjectid, :accept=>"application/serialize"})
+      v = YAML::load(OpenTox::RestClientWrapper.get uri,nil,{:accept=>"application/serialize"})
     end
-    v.subjectid = subjectid
+    #v.subjectid = subjectid
     v.filter_predictions(filter_params[:min_confidence], filter_params[:min_num_predictions], filter_params[:max_num_predictions]) if 
       filter_params
     
@@ -88,22 +88,22 @@ class Reports::ValidationDB
     end
   end
   
-  def init_validation_from_cv_statistics( validation, cv_uri, filter_params, subjectid )
+  def init_validation_from_cv_statistics( validation, cv_uri, filter_params )
     
     bad_request_error "not a crossvalidation uri: "+cv_uri.to_s unless cv_uri =~ /crossvalidation.*\/[0-9]+$/
     
     if same_service?cv_uri
       cv_id = cv_uri.split("/")[-1]
       unauthorized_error "Not authorized: GET "+cv_uri.to_s if
-        $aa[:uri] and !OpenTox::Authorization.authorized?(cv_uri,"GET",subjectid)
+        $aa[:uri] and !OpenTox::Authorization.authorized?(cv_uri,"GET",OpenTox::RestClientWrapper.subjectid)
       Ohm.connect(:thread_safe => true, :port => 6379)
       cv = Validation::Crossvalidation[cv_id]
       resource_not_found_error "crossvalidation with id "+crossvalidation_id.to_s+" not found" unless cv
       bad_request_error "crossvalidation with id "+crossvalidation_id.to_s+" is not finished yet" unless cv.finished
-      v = Validation::Validation.from_cv_statistics(cv_id, subjectid)
+      v = Validation::Validation.from_cv_statistics(cv_id)
     else
-      cv = YAML::load(OpenTox::RestClientWrapper.get cv_uri,nil,{:subjectid=>subjectid, :accept=>"application/serialize"})
-      v = YAML::load(OpenTox::RestClientWrapper.get cv_uri+"/statistics",nil,{:subjectid=>subjectid, :accept=>"application/serialize"})
+      cv = YAML::load(OpenTox::RestClientWrapper.get cv_uri,nil,{:accept=>"application/serialize"})
+      v = YAML::load(OpenTox::RestClientWrapper.get cv_uri+"/statistics",nil,{:accept=>"application/serialize"})
     end
     v.filter_predictions(filter_params[:min_confidence], filter_params[:min_num_predictions], filter_params[:max_num_predictions]) if 
       filter_params
@@ -124,7 +124,7 @@ class Reports::ValidationDB
     validation.validation_uri = cv_uri+"/statistics"
   end
     
-  def init_cv(validation, subjectid)
+  def init_cv(validation)
     
     cv = nil
     if same_service?validation.crossvalidation_uri
@@ -132,15 +132,15 @@ class Reports::ValidationDB
       cv = Validation::Crossvalidation[validation.crossvalidation_id]
       bad_request_error "no crossvalidation found with id "+validation.crossvalidation_id.to_s unless cv
     else
-      cv = YAML::load(OpenTox::RestClientWrapper.get validation.crossvalidation_uri,nil,{:subjectid=>subjectid, :accept=>"application/serialize"})
+      cv = YAML::load(OpenTox::RestClientWrapper.get validation.crossvalidation_uri,nil,{:accept=>"application/serialize"})
     end
     Validation::CROSS_VAL_PROPS.each do |p|
       validation.send("#{p.to_s}=".to_sym, cv.send(p.to_s))
     end
   end
   
-  def training_feature_dataset_uri(validation, subjectid)
-    m = OpenTox::Model::Generic.find(validation.model_uri, subjectid)
+  def training_feature_dataset_uri(validation)
+    m = OpenTox::Model::Generic.find(validation.model_uri)
     if m
       f = m.metadata[RDF::OT.featureDataset]
       return f.chomp if f
@@ -148,9 +148,9 @@ class Reports::ValidationDB
     internal_server_error "no feature dataset found"
   end
 
-  def test_feature_dataset_uri(validation, subjectid)
-    training_features = Lib::DatasetCache.find( training_feature_dataset_uri(validation,subjectid), subjectid )
-    test_dataset = Lib::DatasetCache.find( validation.test_dataset_uri, subjectid )
+  def test_feature_dataset_uri(validation)
+    training_features = Lib::DatasetCache.find( training_feature_dataset_uri(validation))
+    test_dataset = Lib::DatasetCache.find( validation.test_dataset_uri)
     features_found = true 
     training_features.features.each do |f|
       unless test_dataset.features.include?(f)
@@ -164,7 +164,7 @@ class Reports::ValidationDB
       $logger.debug "all training-features found in test-datset"
       uri = test_dataset.uri
     else
-      m = OpenTox::Model::Generic.find(validation.model_uri, subjectid)
+      m = OpenTox::Model::Generic.find(validation.model_uri)
       feat_gen = nil
       m.metadata[RDF::OT.parameters].each do |h|
         if h[RDF::DC.title] and h[RDF::DC.title]=~/feature_generation/ and h[RDF::OT.paramValue]
@@ -174,40 +174,40 @@ class Reports::ValidationDB
       end if m  and m.metadata[RDF::OT.parameters]
       internal_server_error "no feature creation alg found" unless feat_gen
       feat_gen = File.join(feat_gen,"match") if feat_gen=~/fminer/
-      uri = OpenTox::RestClientWrapper.post(feat_gen,{:subjectid => subjectid,
-        :feature_dataset_uri=>training_feature_dataset_uri(validation,subjectid),
+      uri = OpenTox::RestClientWrapper.post(feat_gen,{
+        :feature_dataset_uri=>training_feature_dataset_uri(validation),
         :dataset_uri=>validation.test_dataset_uri})
       @@tmp_resources << wait_for_task(uri)
     end
     uri
   end
   
-  def delete_tmp_resources(subjectid)
+  def delete_tmp_resources
     @@tmp_resources.each do |uri|
-      OpenTox::RestClientWrapper.delete uri,{:subjectid=>subjectid}
+      OpenTox::RestClientWrapper.delete uri
     end
     @@tmp_resources = []
   end
     
-  def get_predictions(validation, filter_params, subjectid, task)
+  def get_predictions(validation, filter_params, task)
     # we need compound info, cannot reuse stored prediction data
     data = Lib::PredictionData.create( validation.feature_type, validation.test_dataset_uri, 
       validation.prediction_feature, validation.prediction_dataset_uri, validation.predicted_variable, 
-      validation.predicted_confidence, subjectid, OpenTox::SubTask.create(task, 0, 80 ) )
+      validation.predicted_confidence, OpenTox::SubTask.create(task, 0, 80 ) )
     data = Lib::PredictionData.filter_data( data.data, data.compounds, 
       filter_params[:min_confidence], filter_params[:min_num_predictions], filter_params[:max_num_predictions] ) if filter_params!=nil
     task.progress(100) if task
     Lib::OTPredictions.new( data.data, data.compounds )
   end
   
-  def get_accept_values( validation, subjectid=nil )
+  def get_accept_values( validation )
     # PENDING So far, one has to load the whole dataset to get the accept_value from ambit
     test_datasets = validation.test_dataset_uri
     res = nil
     test_datasets.split(";").each do |test_dataset|
-      d = Lib::DatasetCache.find( test_dataset, subjectid )
+      d = Lib::DatasetCache.find( test_dataset)
       internal_server_error "cannot get test target dataset for accept values, dataset: "+test_dataset.to_s unless d
-      feature = OpenTox::Feature.find(validation.prediction_feature,subjectid)
+      feature = OpenTox::Feature.find(validation.prediction_feature)
       accept_values = feature.accept_values
       internal_server_error "cannot get accept values for feature "+
         validation.prediction_feature+":\n"+feature.to_yaml unless accept_values!=nil
@@ -217,24 +217,24 @@ class Reports::ValidationDB
     res
   end
   
-  def feature_type( validation, subjectid=nil )
-    m = OpenTox::Model::Generic.new(validation.model_uri,subjectid)
+  def feature_type( validation )
+    m = OpenTox::Model::Generic.new(validation.model_uri)
     #m.get
     m.feature_type
     #get_model(validation).classification?
   end
   
-  def predicted_variable(validation, subjectid=nil)
+  def predicted_variable(validation)
     internal_server_error "cannot derive model depended props for merged validations" if Lib::MergeObjects.merged?(validation)
-    model = OpenTox::Model::Generic.new(validation.model_uri,subjectid)
+    model = OpenTox::Model::Generic.new(validation.model_uri)
     model.get
     resource_not_found_error "model not found '"+validation.model_uri+"'" unless model
     model.predicted_variable
   end
   
-  def predicted_confidence(validation, subjectid=nil)
+  def predicted_confidence(validation)
     internal_server_error "cannot derive model depended props for merged validations" if Lib::MergeObjects.merged?(validation)
-    model = OpenTox::Model::Generic.new(validation.model_uri,subjectid)
+    model = OpenTox::Model::Generic.new(validation.model_uri)
     model.get
     resource_not_found_error "model not found '"+validation.model_uri+"'" unless model
     model.predicted_confidence
diff --git a/report/validation_data.rb b/report/validation_data.rb
index 4623a77..b1064a8 100755
--- a/report/validation_data.rb
+++ b/report/validation_data.rb
@@ -76,8 +76,8 @@ module Reports
   #
   class ReportValidation
     
-    def self.resolve_cv_uris(validation_uris, identifier, subjectid)
-      Reports.validation_access.resolve_cv_uris(validation_uris, identifier, subjectid)
+    def self.resolve_cv_uris(validation_uris, identifier)
+      Reports.validation_access.resolve_cv_uris(validation_uris, identifier)
     end
     
     # create member variables for all validation properties
@@ -87,26 +87,24 @@ module Reports
     @@validation_attributes.each{ |a| attr_accessor a } 
   
     attr_reader :predictions, :filter_params
-    attr_accessor :identifier, :validation_report_uri, :crossvalidation_report_uri, :subjectid
+    attr_accessor :identifier, :validation_report_uri, :crossvalidation_report_uri
     
-    def initialize(uri = nil, filter_params=nil, subjectid = nil)
-      Reports.validation_access.init_validation(self, uri, filter_params, subjectid) if uri
-      @subjectid = subjectid
+    def initialize(uri = nil, filter_params=nil)
+      Reports.validation_access.init_validation(self, uri, filter_params) if uri
       internal_server_error unless filter_params==nil || filter_params.is_a?(Hash)
       @filter_params = filter_params
       @created_resources = []
-      #internal_server_error "subjectid is nil" unless subjectid
     end
     
-    def self.from_cv_statistics( cv_uri, filter_params, subjectid )
-      v = ReportValidation.new(nil, filter_params, subjectid)
-      Reports.validation_access.init_validation_from_cv_statistics(v, cv_uri, filter_params, subjectid)
+    def self.from_cv_statistics( cv_uri, filter_params)
+      v = ReportValidation.new(nil, filter_params)
+      Reports.validation_access.init_validation_from_cv_statistics(v, cv_uri, filter_params)
       v
     end
     
     def training_feature_dataset_uri
       unless @training_feature_dataset
-        @training_feature_dataset = Reports.validation_access.training_feature_dataset_uri( self, @subjectid )
+        @training_feature_dataset = Reports.validation_access.training_feature_dataset_uri( self)
       end
       @training_feature_dataset
     end
@@ -114,7 +112,7 @@ module Reports
     #hack this does create the features for the test dataset
     def test_feature_dataset_uri
       unless @test_feature_dataset
-        @test_feature_dataset = Reports.validation_access.test_feature_dataset_uri( self, @subjectid )
+        @test_feature_dataset = Reports.validation_access.test_feature_dataset_uri( self)
       end
       @test_feature_dataset
     end
@@ -134,7 +132,7 @@ module Reports
           task.progress(100) if task
           nil
         else
-          @predictions = Reports.validation_access.get_predictions( self, @filter_params, @subjectid, task )
+          @predictions = Reports.validation_access.get_predictions( self, @filter_params, task )
         end
       end
     end
@@ -142,7 +140,7 @@ module Reports
     # returns the predictions feature values (i.e. the domain of the class attribute)
     #
     def get_accept_values()
-      @accept_values = Reports.validation_access.get_accept_values(self, @subjectid) unless @accept_values
+      @accept_values = Reports.validation_access.get_accept_values(self) unless @accept_values
       @accept_values
     end
     
@@ -150,23 +148,23 @@ module Reports
     #
     def feature_type
       return @feature_type if @feature_type!=nil
-      @feature_type = Reports.validation_access.feature_type(self, @subjectid) 
+      @feature_type = Reports.validation_access.feature_type(self) 
     end
     
     def predicted_variable
       return @predicted_variable if @predicted_variable!=nil
-      @predicted_variable = Reports.validation_access.predicted_variable(self, @subjectid) 
+      @predicted_variable = Reports.validation_access.predicted_variable(self) 
     end
     
     def predicted_confidence
       return @predicted_confidence if @predicted_confidence!=nil
-      @predicted_confidence = Reports.validation_access.predicted_confidence(self, @subjectid) 
+      @predicted_confidence = Reports.validation_access.predicted_confidence(self) 
     end    
     
     # loads all crossvalidation attributes, of the corresponding cv into this object 
     def load_cv_attributes
       internal_server_error "crossvalidation-id not set" unless @crossvalidation_id
-      Reports.validation_access.init_cv(self, @subjectid)
+      Reports.validation_access.init_cv(self)
       # load cv report
       ids = Reports.persistance.list_reports("crossvalidation",{:crossvalidation=>self.crossvalidation_uri.to_s })
       @crossvalidation_report_uri = ReportService.instance.get_uri("crossvalidation",ids[-1]) if ids and ids.size>0
@@ -185,13 +183,13 @@ module Reports
   #
   class ValidationSet
     
-    def initialize(validation_uris=nil, identifier=nil, filter_params=nil, subjectid=nil)
+    def initialize(validation_uris=nil, identifier=nil, filter_params=nil)
       @unique_values = {}
       @validations = []
       if validation_uris    
-        validation_uri_and_ids = ReportValidation.resolve_cv_uris(validation_uris, identifier, subjectid)
+        validation_uri_and_ids = ReportValidation.resolve_cv_uris(validation_uris, identifier)
         validation_uri_and_ids.each do |u,id|
-          v = ReportValidation.new(u, filter_params, subjectid)
+          v = ReportValidation.new(u, filter_params)
           v.identifier = id if id
           ids = Reports.persistance.list_reports("validation",{:validation_uris=>v.validation_uri })
           v.validation_report_uri = ReportService.instance.get_uri("validation",ids[-1]) if ids and ids.size>0
@@ -451,7 +449,7 @@ module Reports
       new_set = ValidationSet.new
       grouping = Util.group(@validations, [:crossvalidation_id])
       grouping.each do |g|
-        v = ReportValidation.from_cv_statistics(g[0].crossvalidation_uri, @validations.first.filter_params, g[0].subjectid)
+        v = ReportValidation.from_cv_statistics(g[0].crossvalidation_uri, @validations.first.filter_params)
         v.identifier = g.collect{|vv| vv.identifier}.uniq.join(";")
         new_set.validations << v 
       end
@@ -478,7 +476,7 @@ module Reports
       #merge
       Lib::MergeObjects.register_merge_attributes( ReportValidation,
         Validation::VAL_MERGE_AVG+Validation::VAL_MERGE_SUM,[],
-        Validation::VAL_MERGE_GENERAL+[:identifier, :validation_report_uri, :crossvalidation_report_uri, :subjectid]) unless 
+        Validation::VAL_MERGE_GENERAL+[:identifier, :validation_report_uri, :crossvalidation_report_uri]) unless 
           Lib::MergeObjects.merge_attributes_registered?(ReportValidation)
       grouping.each do |g|
         new_set.validations << g[0].clone_validation
diff --git a/test/test_application.rb b/test/test_application.rb
index 2ea8d67..07fd1cc 100755
--- a/test/test_application.rb
+++ b/test/test_application.rb
@@ -5,7 +5,6 @@ post '/test_validation/?' do
   task = OpenTox::Task.run("Test validation",to("/validation/test_validation",:full)) do |task| 
     v = validationExamples[0][0]
     ex = v.new
-    ex.subjectid = @subjectid
     ex.upload_files
     task.progress(10)
     ex.check_requirements
diff --git a/test/test_examples_util.rb b/test/test_examples_util.rb
index 5cc2011..c74da05 100755
--- a/test/test_examples_util.rb
+++ b/test/test_examples_util.rb
@@ -17,7 +17,7 @@ module ValidationExamples
     @@dataset_uris = {}
     @@prediction_features = {}
 
-    def self.upload_dataset(file, subjectid=nil, dataset_service=$dataset[:uri]) #, file_type="application/x-yaml")
+    def self.upload_dataset(file, dataset_service=$dataset[:uri]) #, file_type="application/x-yaml")
       
       raise "File not found: "+file.path.to_s unless File.exist?(file.path)
       if @@dataset_uris[file.path.to_s]==nil
@@ -27,22 +27,20 @@ module ValidationExamples
           #data_uri = OpenTox::RestClientWrapper.post_wait(dataset_service,{:content_type => file_type},data).to_s.chomp
           #@@dataset_uris[file.path.to_s] = data_uri
           #$logger.debug "uploaded dataset: "+data_uri
-          d = OpenTox::Dataset.create($dataset[:uri], subjectid)
+          d = OpenTox::Dataset.create($dataset[:uri])
           d.load_yaml(data)
-          d.save( subjectid )
+          d.put
           @@dataset_uris[file.path.to_s] = d.uri
         elsif (file.path =~ /csv$/)
-          d = OpenTox::Dataset.new nil, subjectid
+          d = OpenTox::Dataset.new 
           d.upload file.path
-          d.get
-          #d = OpenTox::Dataset.create_from_csv_file(file.path, subjectid)
           raise "num features not 1 (="+d.features.size.to_s+"), what to predict??" if d.features.size != 1
           @@prediction_features[file.path.to_s] = d.features[0].uri
           @@dataset_uris[file.path.to_s] = d.uri
         elsif (file.path =~ /rdf$/)
-          d = OpenTox::Dataset.create($dataset[:uri], subjectid)
-          d.load_rdfxml_file(file, subjectid)
-          d.save(subjectid)
+          d = OpenTox::Dataset.create($dataset[:uri])
+          d.load_rdfxml_file(file)
+          d.put
           @@dataset_uris[file.path.to_s] = d.uri
         else
           raise "unknown file type: "+file.path.to_s
@@ -59,7 +57,7 @@ module ValidationExamples
       @@prediction_features[file.path.to_s]
     end
     
-    def self.build_compare_report(validation_examples, subjectid)
+    def self.build_compare_report(validation_examples)
       
       @comp = validation_examples[0].algorithm_uri==nil ? :model_uri : :algorithm_uri
       return nil if @comp == :model_uri
@@ -69,15 +67,14 @@ module ValidationExamples
       end
       return nil if to_compare.size < 2
       #begin
-        return validation_post "report/algorithm_comparison",{ :validation_uris => to_compare.join("\n") }, subjectid
+        return validation_post "report/algorithm_comparison",{ :validation_uris => to_compare.join("\n") }
       #rescue => ex
         #return "error creating comparison report "+ex.message
       #end
     end
     
-    def self.validation_post(uri, params, subjectid, waiting_task=nil, accept_header='application/rdf+xml' )
+    def self.validation_post(uri, params, waiting_task=nil, accept_header='application/rdf+xml' )
       
-      params[:subjectid] = subjectid if subjectid
       if $test_case
         $test_case.post '/validation'+uri,params,'HTTP_ACCEPT' => accept_header 
         uri =  wait($test_case.last_response.body)
@@ -90,9 +87,8 @@ module ValidationExamples
       uri
     end
     
-    def self.validation_get(uri, subjectid, accept_header='application/rdf+xml')
+    def self.validation_get(uri, accept_header='application/rdf+xml')
       params = {}
-      params[:subjectid] = subjectid if subjectid
       if $test_case
         #puts "getting "+uri+","+accept_header
         $test_case.get '/validation'+uri,params,'HTTP_ACCEPT' => accept_header 
@@ -106,10 +102,10 @@ module ValidationExamples
     def self.validation_delete(uri, accept_header='application/rdf+xml')
       
       if $test_case
-        $test_case.delete '/validation'+uri,{:subjectid => SUBJECTID},'HTTP_ACCEPT' => accept_header 
+        $test_case.delete '/validation'+uri,{},'HTTP_ACCEPT' => accept_header 
         return wait($test_case.last_response.body)
       else
-        return OpenTox::RestClientWrapper.delete(File.join($validation[:uri],uri),{:accept => accept_header,:subjectid => SUBJECTID})
+        return OpenTox::RestClientWrapper.delete(File.join($validation[:uri],uri),{:accept => accept_header})
       end
     end
     
@@ -256,7 +252,6 @@ module ValidationExamples
                   :random_seed,
                   :num_folds,
                   :stratified,
-                  :subjectid
     #results                  
     attr_accessor :validation_uri,
                   :report_uri,
@@ -270,7 +265,7 @@ module ValidationExamples
          uri = a[0]
          file = a[1]
          if send(uri)==nil and send(file)!=nil
-            dataset_uri = Util.upload_dataset(send(file), @subjectid)
+            dataset_uri = Util.upload_dataset(send(file))
             send("#{uri.to_s}=".to_sym, dataset_uri)
             @uploaded_datasets = [] unless @uploaded_datasets
             @uploaded_datasets << dataset_uri
@@ -307,7 +302,7 @@ module ValidationExamples
       @uploaded_datasets.each do |d|
        # begin
           puts "deleting dataset "+d
-          OpenTox::RestClientWrapper.delete(d,{:subjectid => SUBJECTID})
+          OpenTox::RestClientWrapper.delete(d)
 #        rescue => ex
           #puts "Could not delete dataset:' "+d+" "+ex.message
         #end
@@ -316,9 +311,8 @@ module ValidationExamples
     
     def report( waiting_task=nil )
       #begin
-        @report_uri = Util.validation_post '/report/'+report_type,{:validation_uris => @validation_uri},
-          @subjectid,waiting_task if @validation_uri
-        Util.validation_get "/report/"+report_uri.split("/")[-2]+"/"+report_uri.split("/")[-1], @subjectid if @report_uri
+        @report_uri = Util.validation_post '/report/'+report_type,{:validation_uris => @validation_uri}, waiting_task if @validation_uri
+        Util.validation_get "/report/"+report_uri.split("/")[-2]+"/"+report_uri.split("/")[-1] if @report_uri
       #rescue => ex
         #puts "could not create report: "+ex.message
         #raise ex
@@ -328,7 +322,7 @@ module ValidationExamples
     
     def validate( waiting_task=nil )
       #begin
-        @validation_uri = Util.validation_post '/'+validation_type, get_params, @subjectid, waiting_task
+        @validation_uri = Util.validation_post '/'+validation_type, get_params, waiting_task
       #rescue => ex
         #puts "could not validate: "+ex.message
         #@validation_error = ex.message
@@ -338,15 +332,15 @@ module ValidationExamples
     
     def compare_yaml_vs_rdf
       if @validation_uri
-        yaml = YAML.load(Util.validation_get(@validation_uri.split("/")[-1],@subjectid,'application/x-yaml'))
-        owl = OpenTox::Owl.from_data(Util.validation_get(@validation_uri.split("/")[-1],@subjectid),@validation_uri,"Validation")
+        yaml = YAML.load(Util.validation_get(@validation_uri.split("/")[-1],'application/x-yaml'))
+        owl = OpenTox::Owl.from_data(Util.validation_get(@validation_uri.split("/")[-1]),@validation_uri,"Validation")
         Util.compare_yaml_and_owl(yaml,owl)
       end
       if @report_uri
-        yaml = YAML.load(Util.validation_get(@report_uri.split("/")[-3..-1].join("/"),@subjectid,'application/x-yaml'))
-        owl = OpenTox::Owl.from_data(Util.validation_get(@report_uri.split("/")[-3..-1].join("/"),@subjectid),@report_uri,"ValidationReport")
+        yaml = YAML.load(Util.validation_get(@report_uri.split("/")[-3..-1].join("/"),'application/x-yaml'))
+        owl = OpenTox::Owl.from_data(Util.validation_get(@report_uri.split("/")[-3..-1].join("/")),@report_uri,"ValidationReport")
         Util.compare_yaml_and_owl(yaml,owl)
-        Util.validation_get(@report_uri.split("/")[-3..-1].join("/"),@subjectid,'text/html')
+        Util.validation_get(@report_uri.split("/")[-3..-1].join("/"),'text/html')
       else
         puts "no report"
       end
@@ -354,7 +348,7 @@ module ValidationExamples
     
     def compute_dataset_size
       if @validation_uri =~ /crossvalidation/
-        cv = OpenTox::Crossvalidation.find(@validation_uri,@subjectid)
+        cv = OpenTox::Crossvalidation.find(@validation_uri)
         count = 0
         size = 0
         target = nil
@@ -411,7 +405,7 @@ module ValidationExamples
         Util.validation_get("crossvalidation/"+@validation_uri.split("/")[-1]+"/statistics",'application/x-yaml')
         Util.verify_validation(Util.validation_get("crossvalidation/"+@validation_uri.split("/")[-1]+"/statistics",'application/x-yaml'))
       else
-        Util.verify_validation(Util.validation_get(@validation_uri.split("/")[-1],@subjectid,'application/x-yaml'))
+        Util.verify_validation(Util.validation_get(@validation_uri.split("/")[-1],'application/x-yaml'))
       end
     end
     
diff --git a/validation/validation_application.rb b/validation/validation_application.rb
index 4bd7942..fa4f4d3 100755
--- a/validation/validation_application.rb
+++ b/validation/validation_application.rb
@@ -28,7 +28,7 @@ class Validation::Application < OpenTox::Service
       $logger.info "list all crossvalidations "+params.inspect
       model_uri = params.delete("model") || params.delete("model_uri")
       if model_uri
-        model = OpenTox::Model::Generic.find(model_uri, @subjectid)
+        model = OpenTox::Model::Generic.find(model_uri)
         params[:algorithm] = model.metadata[RDF::OT.algorithm]
         params[:dataset] = model.metadata[RDF::OT.trainingDataset]
       end
@@ -72,14 +72,12 @@ class Validation::Application < OpenTox::Service
                       :algorithm_params => params[:algorithm_params],
                       :prediction_feature => params[:prediction_feature],
                       :stratified => params[:stratified],
-                      :loo => "false",
-                      :subjectid => @subjectid }
+                      :loo => "false" }
         [ :num_folds, :random_seed ].each{ |sym| cv_params[sym] = params[sym] if params[sym] }
         cv = Validation::Crossvalidation.create cv_params
-        cv.subjectid = @subjectid
         cv.perform_cv( OpenTox::SubTask.create(task,0,95) )
         # computation of stats is cheap as dataset are already loaded into the memory
-        Validation::Validation.from_cv_statistics( cv.id, @subjectid, OpenTox::SubTask.create(task,95,100) )
+        Validation::Validation.from_cv_statistics( cv.id, OpenTox::SubTask.create(task,95,100) )
         cv.crossvalidation_uri
       end
       return_task(task)
@@ -90,10 +88,9 @@ class Validation::Application < OpenTox::Service
       content_type "text/uri-list"
       deleted = []
       Validation::Crossvalidation.all.collect.delete_if{|cv| cv.finished}.each do |cv|
-        if OpenTox::Authorization.authorized?(cv.crossvalidation_uri,"DELETE",@subjectid)
+        if OpenTox::Authorization.authorized?(cv.crossvalidation_uri,"DELETE",OpenTox::RestClientWrapper.subjectid)
           $logger.debug "delete cv with id:"+cv.id.to_s+", finished is false"
           deleted << cv.crossvalidation_uri
-          cv.subjectid = @subjectid
           cv.delete_crossvalidation
           sleep 1 if $aa[:uri]
         end
@@ -116,10 +113,9 @@ class Validation::Application < OpenTox::Service
                       :algorithm_uri => params[:algorithm_uri],
                       :loo => "true" }
         cv = Validation::Crossvalidation.create cv_params
-        cv.subjectid = @subjectid
         cv.perform_cv( OpenTox::SubTask.create(task,0,95))
         # computation of stats is cheap as dataset are already loaded into the memory
-        Validation::Validation.from_cv_statistics( cv.id, @subjectid, OpenTox::SubTask.create(task,95,100) )
+        Validation::Validation.from_cv_statistics( cv.id, OpenTox::SubTask.create(task,95,100) )
         cv.clean_loo_files( !(params[:algorithm_params] && params[:algorithm_params] =~ /feature_dataset_uri/) )
         cv.crossvalidation_uri
       end
@@ -192,7 +188,7 @@ class Validation::Application < OpenTox::Service
     get '/validation/crossvalidation/:id/statistics' do
       
       $logger.info "get crossvalidation statistics for crossvalidation with id "+params[:id].to_s
-      v = Validation::Validation.from_cv_statistics( params[:id], @subjectid )
+      v = Validation::Validation.from_cv_statistics( params[:id] )
       case request.env['HTTP_ACCEPT'].to_s
       when /text\/html/
         related_links = 
@@ -218,7 +214,7 @@ class Validation::Application < OpenTox::Service
       
       $logger.info "get crossvalidation statistics for crossvalidation with id "+params[:id].to_s
       bad_request_error("Missing params, plz give confidence and prediction") unless params[:confidence] and params[:prediction]
-      v = Validation::Validation.from_cv_statistics( params[:id], @subjectid )
+      v = Validation::Validation.from_cv_statistics( params[:id] )
       props = v.probabilities(params[:confidence].to_s.to_f,params[:prediction].to_s)
       content_type "text/x-yaml"
       props.to_yaml
@@ -236,7 +232,6 @@ class Validation::Application < OpenTox::Service
       
       cv = Validation::Crossvalidation[params[:id]]
       resource_not_found_error "Crossvalidation '#{params[:id]}' not found." unless cv
-      cv.subjectid = @subjectid
       cv.delete_crossvalidation
     end
     
@@ -319,7 +314,6 @@ class Validation::Application < OpenTox::Service
                            :model_uri => params[:model_uri], 
                            :test_dataset_uri => params[:test_dataset_uri],
                            :prediction_feature => params[:prediction_feature]
-          v.subjectid = @subjectid
           v.validate_model( task )
           v.validation_uri
         end
@@ -369,7 +363,6 @@ class Validation::Application < OpenTox::Service
                             :training_dataset_uri => params[:training_dataset_uri], 
                             :test_dataset_uri => params[:test_dataset_uri],
                             :prediction_feature => params[:prediction_feature]
-          v.subjectid = @subjectid
           v.validate_algorithm( task ) 
           v.validation_uri
         end
@@ -416,7 +409,7 @@ class Validation::Application < OpenTox::Service
       bad_request_error "prediction_feature missing" unless params[:prediction_feature].to_s.size>0
       task = OpenTox::Task.run( "Perform bootstrapping validation", to("/validation/bootstrapping", :full) ) do |task| #, params
         params.merge!( Validation::Util.bootstrapping( params[:dataset_uri], 
-          params[:prediction_feature], @subjectid, 
+          params[:prediction_feature],
           params[:random_seed], OpenTox::SubTask.create(task,0,33)) )
         $logger.info "params after bootstrapping: "+params.inspect
         v = Validation::Validation.create :validation_type => "bootstrapping", 
@@ -425,7 +418,6 @@ class Validation::Application < OpenTox::Service
                          :algorithm_params => params[:algorithm_params],
                          :training_dataset_uri => params[:training_dataset_uri], 
                          :test_dataset_uri => params[:test_dataset_uri]
-        v.subjectid = @subjectid
         v.validate_algorithm( OpenTox::SubTask.create(task,33,100))
         v.validation_uri
       end
@@ -474,10 +466,10 @@ class Validation::Application < OpenTox::Service
       bad_request_error "algorithm_uri missing" unless params[:algorithm_uri].to_s.size>0
       bad_request_error "prediction_feature missing" unless params[:prediction_feature].to_s.size>0
       check_stratified(params)
-      task = OpenTox::Task.run( "Perform training test split validation", uri("/validation/training_test_split"), @subjectid )  do |task| #, params
+      task = OpenTox::Task.run( "Perform training test split validation", uri("/validation/training_test_split"))  do |task| #, params
         $logger.debug "performing train test split"
         params.merge!( Validation::Util.train_test_dataset_split(to("/validation/training_test_split", :full), params[:dataset_uri], 
-          (params[:stratified].to_s=~/true/ ? params[:prediction_feature] : nil), @subjectid,  params[:stratified], params[:split_ratio], 
+          (params[:stratified].to_s=~/true/ ? params[:prediction_feature] : nil), params[:stratified], params[:split_ratio], 
           params[:random_seed], OpenTox::SubTask.create(task,0,33)))
         $logger.debug "creating validation"  
         v = Validation::Validation.create :validation_type => "training_test_split", 
@@ -486,7 +478,6 @@ class Validation::Application < OpenTox::Service
                          :prediction_feature => params[:prediction_feature],
                          :algorithm_uri => params[:algorithm_uri],
                          :algorithm_params => params[:algorithm_params]
-        v.subjectid = @subjectid
         $logger.debug "created validation, validating algorithm"
         v.validate_algorithm( OpenTox::SubTask.create(task,33,100))
         v.validation_uri
@@ -530,10 +521,9 @@ class Validation::Application < OpenTox::Service
       content_type "text/uri-list"
       deleted = []
       Validation::Validation.all.collect.delete_if{|val| val.finished}.each do |val|
-        if OpenTox::Authorization.authorized?(val.validation_uri,"DELETE",@subjectid)
+        if OpenTox::Authorization.authorized?(val.validation_uri,"DELETE",OpenTox::RestClientWrapper.subjectid)
           $logger.debug "delete val with id:"+val.id.to_s+", finished is false"
           deleted << val.validation_uri
-          val.subjectid = @subjectid
           val.delete_validation
           sleep 1 if $aa[:uri]
         end
@@ -556,9 +546,9 @@ class Validation::Application < OpenTox::Service
       end
       deleted = []
       OpenTox::Dataset.all.each do |d|
-        if !used_datasets.include?(d.uri) and OpenTox::Authorization.authorized?(d.uri,"DELETE",@subjectid)
+        if !used_datasets.include?(d.uri) and OpenTox::Authorization.authorized?(d.uri,"DELETE",OpenTox::RestClientWrapper.subjectid)
           deleted << d.uri
-          d.delete(@subjectid)
+          d.delete
           sleep 1 if $aa[:uri]
         end
       end
@@ -572,7 +562,7 @@ class Validation::Application < OpenTox::Service
       check_stratified(params)
       task = OpenTox::Task.run( "Create data-split", to("/validation/plain_training_test_split", :full) ) do |task|
         result = Validation::Util.train_test_dataset_split(to("/validation/plain_training_test_split", :full), params[:dataset_uri], params[:prediction_feature], 
-          @subjectid, params[:stratified], params[:split_ratio], params[:random_seed], task)
+          params[:stratified], params[:split_ratio], params[:random_seed], task)
         content_type "text/uri-list"
         result[:training_dataset_uri]+"\n"+result[:test_dataset_uri]+"\n"
       end
@@ -589,7 +579,6 @@ class Validation::Application < OpenTox::Service
         if params[:model_uri]
           bad_request_error "please specify 'model_uri' or set either 'classification' or 'regression' flag" if params[:classification] or params[:regression]
           v = Validation::Validation.create params
-          v.subjectid = @subjectid
           v.compute_validation_stats_with_model(nil,false,task)
         else
           bad_request_error "please specify 'model_uri' or 'prediction_feature'" unless params[:prediction_feature]
@@ -601,7 +590,6 @@ class Validation::Application < OpenTox::Service
           feature_type = "classification" if params.delete("classification")!=nil
           feature_type = "regression" if params.delete("regression")!=nil
           v = Validation::Validation.create params  
-          v.subjectid = @subjectid
           v.compute_prediction_data(feature_type,predicted_variable,predicted_confidence,v.prediction_feature,nil,task)
           v.compute_validation_stats()#feature_type,predicted_variable,predicted_confidence,nil,nil,false,task)
         end
@@ -618,7 +606,6 @@ class Validation::Application < OpenTox::Service
       rescue ActiveRecord::RecordNotFound => ex
         resource_not_found_error("Validation '#{params[:id]}' not found.")
       end
-      validation.subjectid = @subjectid
       bad_request_error("Validation '"+params[:id].to_s+"' not finished") unless validation.finished
       bad_request_error("Missing params, plz give confidence and prediction") unless params[:confidence] and params[:prediction]
       props = validation.probabilities(params[:confidence].to_s.to_f,params[:prediction].to_s)
@@ -710,7 +697,6 @@ class Validation::Application < OpenTox::Service
     #    resource_not_found_error "Validation '#{params[:id]}' not found."
     #  end
       validation = Validation::Validation[params[:id]]
-      validation.subjectid = @subjectid
       resource_not_found_error "Validation '#{params[:id]}' not found." unless validation
       content_type "text/plain"
       validation.delete_validation
diff --git a/validation/validation_service.rb b/validation/validation_service.rb
index 80a7b6b..67009df 100755
--- a/validation/validation_service.rb
+++ b/validation/validation_service.rb
@@ -39,7 +39,7 @@ module Validation
   
   class Validation
     
-    def self.from_cv_statistics( cv_id, subjectid=nil, waiting_task=nil )
+    def self.from_cv_statistics( cv_id, waiting_task=nil )
       v =  Validation.find( :crossvalidation_id => cv_id, :validation_type => "crossvalidation_statistics" ).first
       unless v
         crossvalidation = Crossvalidation[cv_id]
@@ -48,7 +48,6 @@ module Validation
         vals = Validation.find( :crossvalidation_id => cv_id, :validation_type => "crossvalidation" ).collect{|x| x}
         
         v = Validation.new
-        v.subjectid = subjectid
         v.compute_prediction_data_with_cv(vals, waiting_task)
         v.compute_validation_stats()
           
@@ -62,7 +61,6 @@ module Validation
         v.real_runtime = vals.collect{ |vv| vv.real_runtime }.uniq.join(";")
         v.save
       end
-      v.subjectid = subjectid
       waiting_task.progress(100) if waiting_task
       v
     end
@@ -95,7 +93,7 @@ module Validation
             uri = self.send(attr)
             $logger.debug "also deleting "+attr.to_s+" : "+uri.to_s if uri
             begin
-              OpenTox::RestClientWrapper.delete(uri, :subjectid => subjectid) if uri
+              OpenTox::RestClientWrapper.delete(uri) if uri
               sleep 1 if $aa[:uri] # wait a second to not stress the a&a service too much
             rescue => ex
               $logger.warn "could not delete "+uri.to_s+" : "+ex.message.to_s
@@ -104,10 +102,10 @@ module Validation
         end
       end
       self.delete
-      if (subjectid)
+      if (OpenTox::RestClientWrapper.subjectid)
         Thread.new do
           begin
-            res = OpenTox::Authorization.delete_policies_from_uri(validation_uri, subjectid)
+            res = OpenTox::Authorization.delete_policies_from_uri(validation_uri, OpenTox::RestClientWrapper.subjectid)
             $logger.debug "Deleted validation policy: #{res}"
           rescue
             $logger.warn "Policy delete error for validation: #{validation_uri}"
@@ -168,7 +166,7 @@ module Validation
       
       #model = OpenTox::Model::PredictionModel.find(self.model_uri)
       #resource_not_found_error "model not found: "+self.model_uri.to_s unless model
-      model = OpenTox::Model::Generic.new(self.model_uri, self.subjectid)
+      model = OpenTox::Model::Generic.new(self.model_uri)
       
       unless self.algorithm_uri
         self.algorithm_uri = model.metadata[RDF::OT.algorithm]
@@ -185,7 +183,7 @@ module Validation
         #puts self.test_dataset_uri
         #puts "MODEL"
         #puts model.uri
-        prediction_dataset_uri = model.run({:dataset_uri => self.test_dataset_uri, :subjectid => self.subjectid})
+        prediction_dataset_uri = model.run({:dataset_uri => self.test_dataset_uri})
           #"text/uri-list",OpenTox::SubTask.create(task, 0, 50))
       end
 #      self.attributes = { :prediction_dataset_uri => prediction_dataset_uri,
@@ -201,25 +199,25 @@ module Validation
     end
     
     def compute_prediction_data_with_cv(cv_vals, waiting_task=nil)
-      models = cv_vals.collect{|v| m = OpenTox::Model::Generic.new(v.model_uri, subjectid); m.get; m}
-      feature_type = models.first.feature_type # CH: subjectid is a object variable, no need to pass it as a parameter
+      models = cv_vals.collect{|v| m = OpenTox::Model::Generic.new(v.model_uri); m.get; m}
+      feature_type = models.first.feature_type 
       test_dataset_uris = cv_vals.collect{|v| v.test_dataset_uri}
       prediction_feature = cv_vals.first.prediction_feature
       prediction_dataset_uris = cv_vals.collect{|v| v.prediction_dataset_uri}
       predicted_variables = models.collect{|m| m.predicted_variable}
       predicted_confidences = models.collect{|m| m.predicted_confidence}
       p_data = Lib::PredictionData.create( feature_type, test_dataset_uris, prediction_feature, 
-        prediction_dataset_uris, predicted_variables, predicted_confidences, subjectid, waiting_task )
+        prediction_dataset_uris, predicted_variables, predicted_confidences, waiting_task )
       self.prediction_data = p_data.data
       p_data.data
     end
     
     def compute_prediction_data_with_model(model=nil, task=nil)
       #model = OpenTox::Model::Generic.find(self.model_uri, self.subjectid) if model==nil and self.model_uri
-      model = OpenTox::Model.find(self.model_uri, self.subjectid) if model==nil and self.model_uri
+      model = OpenTox::Model.find(self.model_uri) if model==nil and self.model_uri
       resource_not_found_error "model not found: "+self.model_uri.to_s unless model
             
-      feature_type = model.feature_type # CH: subjectid is a object variable, no need to pass it as a parameter
+      feature_type = model.feature_type 
       dependentVariables = model.metadata[RDF::OT.dependentVariables]
       prediction_feature = self.prediction_feature ? nil : dependentVariables
       algorithm_uri = self.algorithm_uri ? nil : model.metadata[RDF::OT.algorithm]
@@ -241,7 +239,7 @@ module Validation
       $logger.debug "computing prediction stats"
       p_data = Lib::PredictionData.create( feature_type, 
         self.test_dataset_uri, self.prediction_feature, 
-        self.prediction_dataset_uri, predicted_variable, predicted_confidence, self.subjectid,
+        self.prediction_dataset_uri, predicted_variable, predicted_confidence, 
         OpenTox::SubTask.create(task, 0, 80) )
       self.prediction_data = p_data.data
       task.progress(100) if task
@@ -325,13 +323,13 @@ module Validation
     def clean_loo_files( delete_feature_datasets )
       Validation.find( :crossvalidation_id => self.id, :validation_type => "crossvalidation" ).each do |v|
         $logger.debug "loo-cleanup> delete training dataset "+v.training_dataset_uri
-        OpenTox::RestClientWrapper.delete v.training_dataset_uri,subjectid
+        OpenTox::RestClientWrapper.delete v.training_dataset_uri
         if (delete_feature_datasets)
           begin
             model = OpenTox::Model::Generic.find(v.model_uri)
             if model.metadata[RDF::OT.featureDataset]
               $logger.debug "loo-cleanup> delete feature dataset "+model.metadata[RDF::OT.featureDataset]
-              OpenTox::RestClientWrapper.delete model.metadata[RDF::OT.featureDataset],subjectid
+              OpenTox::RestClientWrapper.delete model.metadata[RDF::OT.featureDataset]
             end
           rescue
           end
@@ -344,17 +342,16 @@ module Validation
       validations = Validation.find(:crossvalidation_id => self.id) 
       Thread.new do # do deleting in background to not cause a timeout
         validations.each do |v|
-          v.subjectid = self.subjectid
           $logger.debug "deleting cv-validation "+v.validation_uri.to_s
           v.delete_validation
           sleep 1 if $aa[:uri] # wait a second to not stress the a&a service too much
         end
       end
       self.delete
-      if (subjectid)
+      if (OpenTox::RestClientWrapper.subjectid)
         Thread.new do
           begin
-            res = OpenTox::Authorization.delete_policies_from_uri(crossvalidation_uri, subjectid)
+            res = OpenTox::Authorization.delete_policies_from_uri(crossvalidation_uri, OpenTox::RestClientWrapper.subjectid)
             $logger.debug "Deleted crossvalidation policy: #{res}"
           rescue
             $logger.warn "Policy delete error for crossvalidation: #{crossvalidation_uri}"
@@ -367,7 +364,7 @@ module Validation
     # creates the cv folds
     def create_cv_datasets( task=nil )
       if self.loo=="true"
-        orig_dataset = Lib::DatasetCache.find(self.dataset_uri,self.subjectid)
+        orig_dataset = Lib::DatasetCache.find(self.dataset_uri)
         self.num_folds = orig_dataset.compounds.size
         self.random_seed = 0
         self.stratified = "false"
@@ -392,7 +389,6 @@ module Validation
       task_step = 100 / self.num_folds.to_f;
       @tmp_validations.each do | val |
         validation = Validation.create val
-        validation.subjectid = self.subjectid
         validation.validate_algorithm( OpenTox::SubTask.create(task, i * task_step, ( i + 1 ) * task_step) )
         internal_server_error "validation '"+validation.validation_uri+"' for crossvaldation could not be finished" unless 
           validation.finished
@@ -422,13 +418,13 @@ module Validation
                                           (cv.prediction_feature && 
                                            cv.prediction_feature != self.prediction_feature)) }
       cvs.each do |cv|
-        next if $aa[:uri] and !OpenTox::Authorization.authorized?(cv.crossvalidation_uri,"GET",self.subjectid)
+        next if $aa[:uri] and !OpenTox::Authorization.authorized?(cv.crossvalidation_uri,"GET",OpenTox::RestClientWrapper.subjectid)
         tmp_val = []
         Validation.find( :crossvalidation_id => cv.id, :validation_type => "crossvalidation" ).each do |v|
           break unless 
             v.prediction_feature == prediction_feature and
-            URI.accessible?(v.training_dataset_uri,self.subjectid) and 
-            URI.accessible?(v.test_dataset_uri,self.subjectid)
+            URI.accessible?(v.training_dataset_uri) and 
+            URI.accessible?(v.test_dataset_uri)
             # CH: Dataset.exist? has been removed, URI.accessible? is cheaper because it needs only HEAD requests 
             #OpenTox::Dataset.exist?(v.training_dataset_uri,self.subjectid) and 
             #OpenTox::Dataset.exist?(v.test_dataset_uri,self.subjectid)
@@ -456,7 +452,7 @@ module Validation
     # stores uris in validation objects 
     def create_new_cv_datasets( task = nil )
       $logger.debug "creating datasets for crossvalidation"
-      orig_dataset = Lib::DatasetCache.find(self.dataset_uri,self.subjectid)
+      orig_dataset = Lib::DatasetCache.find(self.dataset_uri)
       resource_not_found_error "Dataset not found: "+self.dataset_uri.to_s unless orig_dataset
       
       train_dataset_uris = []
@@ -492,11 +488,11 @@ module Validation
           datasetname = 'dataset fold '+(n+1).to_s+' of '+self.num_folds.to_s        
           meta[RDF::DC.title] = "training "+datasetname 
           $logger.debug "training set: "+datasetname+"_train, compounds: "+train_compound_indices.size.to_s
-          train_dataset_uri = orig_dataset.split( train_compound_indices, orig_dataset.features, meta, self.subjectid ).uri
+          train_dataset_uri = orig_dataset.split( train_compound_indices, orig_dataset.features, meta ).uri
           train_dataset_uris << train_dataset_uri
           meta[RDF::DC.title] = "test "+datasetname
           $logger.debug "test set:     "+datasetname+"_test, compounds: "+test_compound_indices.size.to_s
-          test_dataset_uri = orig_dataset.split( test_compound_indices, orig_dataset.features, meta, self.subjectid ).uri
+          test_dataset_uri = orig_dataset.split( test_compound_indices, orig_dataset.features, meta ).uri
           test_dataset_uris << test_dataset_uri
         end
       when /true|super/
@@ -507,7 +503,7 @@ module Validation
         end
         r_util = OpenTox::RUtil.new 
         train_datasets, test_datasets = r_util.stratified_k_fold_split(orig_dataset,meta,
-          "NA",self.num_folds.to_i,@subjectid,self.random_seed, features)
+          "NA",self.num_folds.to_i,self.random_seed, features)
         r_util.quit_r
         train_dataset_uris = train_datasets.collect{|d| d.uri}
         test_dataset_uris = test_datasets.collect{|d| d.uri}
@@ -536,11 +532,11 @@ module Validation
     # splits a dataset into test and training dataset via bootstrapping
     # (training dataset-size is n, sampling from orig dataset with replacement)
     # returns map with training_dataset_uri and test_dataset_uri
-    def self.bootstrapping( orig_dataset_uri, prediction_feature, subjectid, random_seed=nil, task=nil )
+    def self.bootstrapping( orig_dataset_uri, prediction_feature, random_seed=nil, task=nil )
       
       random_seed=1 unless random_seed
       
-      orig_dataset = Lib::DatasetCache.find orig_dataset_uri,subjectid
+      orig_dataset = Lib::DatasetCache.find orig_dataset_uri
       orig_dataset.load_all
       resource_not_found_error "Dataset not found: "+orig_dataset_uri.to_s unless orig_dataset
       if prediction_feature
@@ -579,14 +575,14 @@ module Validation
       result = {}
       result[:training_dataset_uri] = orig_dataset.split( training_compound_indices, orig_dataset.features, 
         { RDF::DC.title => "Bootstrapping training dataset of "+orig_dataset.title.to_s,
-          RDF::DC.creator => $url_provider.to('/validation/bootstrapping',:full) },
-        subjectid ).uri
+          RDF::DC.creator => $url_provider.to('/validation/bootstrapping',:full) }
+        ).uri
       task.progress(66) if task
 
       result[:test_dataset_uri] = orig_dataset.split( test_compound_indices, orig_dataset.features,
         { RDF::DC.title => "Bootstrapping test dataset of "+orig_dataset.title.to_s,
-          RDF::DC.creator => $url_provider.to('/validation/bootstrapping',:full)} ,
-        subjectid ).uri
+          RDF::DC.creator => $url_provider.to('/validation/bootstrapping',:full)}
+        ).uri
       task.progress(100) if task
       
       $logger.debug "bootstrapping done, training dataset: '"+result[:training_dataset_uri].to_s+"', test dataset: '"+result[:test_dataset_uri].to_s+"'"
@@ -595,7 +591,7 @@ module Validation
     
     # splits a dataset into test and training dataset
     # returns map with training_dataset_uri and test_dataset_uri
-    def self.train_test_dataset_split( creator_uri, orig_dataset_uri, prediction_feature, subjectid, stratified="false", split_ratio=nil, random_seed=nil, task=nil )
+    def self.train_test_dataset_split( creator_uri, orig_dataset_uri, prediction_feature, stratified="false", split_ratio=nil, random_seed=nil, task=nil )
       
       $logger.debug "train test split"
       
@@ -606,7 +602,7 @@ module Validation
       
       resource_not_found_error "Split ratio invalid: "+split_ratio.to_s unless split_ratio and split_ratio=split_ratio.to_f
       resource_not_found_error "Split ratio not >0 and <1 :"+split_ratio.to_s unless split_ratio>0 && split_ratio<1
-      orig_dataset = Lib::DatasetCache.find orig_dataset_uri, subjectid
+      orig_dataset = Lib::DatasetCache.find orig_dataset_uri
       resource_not_found_error "Dataset not found: "+orig_dataset_uri.to_s unless orig_dataset
       
       if prediction_feature
@@ -631,7 +627,7 @@ module Validation
           features = nil
         end
         r_util = OpenTox::RUtil.new 
-        train, test = r_util.stratified_split( orig_dataset, meta, "NA", split_ratio, @subjectid, random_seed, features )
+        train, test = r_util.stratified_split( orig_dataset, meta, "NA", split_ratio, random_seed, features )
         r_util.quit_r
         result = {:training_dataset_uri => train.uri, :test_dataset_uri => test.uri}
       when "false"
diff --git a/validation/validation_test.rb b/validation/validation_test.rb
index 6616575..f7eb632 100755
--- a/validation/validation_test.rb
+++ b/validation/validation_test.rb
@@ -33,18 +33,21 @@ $logger = OTLogger.new(STDOUT)
 $logger.datetime_format = "%Y-%m-%d %H:%M:%S "
 $logger.formatter = Logger::Formatter.new
 
+# Authorisation happens in opentox-client.rb
+=begin
 if $aa[:uri]
   #TEST_USER = "mgtest"
   #TEST_PW = "mgpasswd"
   TEST_USER = "guest"
   TEST_PW = "guest"
-  SUBJECTID = OpenTox::Authorization.authenticate(TEST_USER,TEST_PW)
+  #SUBJECTID = OpenTox::Authorization.authenticate(TEST_USER,TEST_PW)
   raise "could not log in" unless SUBJECTID
   puts "logged in: "+SUBJECTID.to_s
 else
   puts "AA disabled"
   SUBJECTID = nil
 end
+=end
 
 #Rack::Test::DEFAULT_HOST = "local-ot" #"/validation"
 
@@ -374,8 +377,8 @@ class ValidationTest < Test::Unit::TestCase
   
   def run_test(select=nil, overwrite={}, delete=false )
     
-    if $aa[:uri] && SUBJECTID && delete
-      policies_before = OpenTox::Authorization.list_policy_uris(SUBJECTID)
+    if $aa[:uri] && OpenTox::RestClientWrapper.subjectid && delete
+      policies_before = OpenTox::Authorization.list_policy_uris(OpenTox::RestClientWrapper.subjectid)
     end
     
     puts ValidationExamples.list unless select
@@ -383,7 +386,6 @@ class ValidationTest < Test::Unit::TestCase
     validationExamples.each do |vv|
       vv.each do |v| 
         ex = v.new
-        ex.subjectid = SUBJECTID
         
         overwrite.each do |k,v|
           ex.send(k.to_s+"=",v)
@@ -401,8 +403,8 @@ class ValidationTest < Test::Unit::TestCase
         #break
         
         if !delete and ex.validation_uri
-          if SUBJECTID
-            puts ex.validation_uri+"?subjectid="+CGI.escape(SUBJECTID)
+          if OpenTox::RestClientWrapper.subjectid
+            puts ex.validation_uri+"?subjectid="+CGI.escape(OpenTox::RestClientWrapper.subjectid)
           else
             puts ex.validation_uri
           end
@@ -412,8 +414,8 @@ class ValidationTest < Test::Unit::TestCase
           ex.report
         end
         if !delete and ex.report_uri
-          if SUBJECTID  
-            puts ex.report_uri+"?subjectid="+CGI.escape(SUBJECTID)
+          if OpenTox::RestClientWrapper.subjectid  
+            puts ex.report_uri+"?subjectid="+CGI.escape(OpenTox::RestClientWrapper.subjectid)
           else
             puts ex.report_uri
           end
@@ -424,8 +426,8 @@ class ValidationTest < Test::Unit::TestCase
       end
     end
     
-    if $aa[:uri] && SUBJECTID && delete
-      policies_after= OpenTox::Authorization.list_policy_uris(SUBJECTID)
+    if $aa[:uri] && OpenTox::RestClientWrapper.subjectid && delete
+      policies_after= OpenTox::Authorization.list_policy_uris(OpenTox::RestClientWrapper.subjectid)
       diff = policies_after.size - policies_before.size
       if (diff != 0)
         policies_before.each do |k,v|