adjust to new A&A for GET, remove old Report-Errorreporting

15 files changed, 152 insertions, 145 deletions

diff --git a/application.rb b/application.rb
index 89785e1..cf9621d 100755
--- a/application.rb
+++ b/application.rb
@@ -9,6 +9,8 @@ end
   #LOGGER.datetime_format = "%Y-%m-%d %H:%M:%S "
 #end
 
+#require "error_application.rb"
+
 require "example.rb"
 
 get '/examples/?' do
diff --git a/lib/ot_predictions.rb b/lib/ot_predictions.rb
index 50934e5..c593f55 100755
--- a/lib/ot_predictions.rb
+++ b/lib/ot_predictions.rb
@@ -16,7 +16,7 @@ module Lib
     end
   
     def initialize(feature_type, test_dataset_uri, test_target_dataset_uri, 
-      prediction_feature, prediction_dataset_uri, predicted_variable, task=nil)
+      prediction_feature, prediction_dataset_uri, predicted_variable, subjectid=nil, task=nil)
       
         LOGGER.debug("loading prediciton via test-dataset:'"+test_dataset_uri.to_s+
           "', test-target-datset:'"+test_target_dataset_uri.to_s+
@@ -31,7 +31,7 @@ module Lib
          
         predicted_variable=prediction_feature if predicted_variable==nil
         
-        test_dataset = OpenTox::Dataset.find test_dataset_uri
+        test_dataset = OpenTox::Dataset.find test_dataset_uri,subjectid
         raise "test dataset not found: '"+test_dataset_uri.to_s+"'" unless test_dataset
         raise "prediction_feature missing" unless prediction_feature
         
@@ -43,7 +43,7 @@ module Lib
                 "test_dataset: '"+test_target_dataset_uri.to_s+"'\n"+
                 "available features are: "+test_target_dataset.features.inspect if test_target_dataset.features.index(prediction_feature)==nil
         else
-          test_target_dataset = OpenTox::Dataset.find test_target_dataset_uri
+          test_target_dataset = OpenTox::Dataset.find test_target_dataset_uri,subjectid
           raise "test target datset not found: '"+test_target_dataset_uri.to_s+"'" unless test_target_dataset
           if CHECK_VALUES
             test_dataset.compounds.each do |c|
@@ -56,7 +56,7 @@ module Lib
                 "available features are: "+test_target_dataset.features.inspect if test_target_dataset.features.keys.index(prediction_feature)==nil
         end
         
-        test_dataset.load_all
+        test_dataset.load_all(subjectid)
         @compounds = test_dataset.compounds
         LOGGER.debug "test dataset size: "+@compounds.size.to_s
         raise "test dataset is empty" unless @compounds.size>0
@@ -73,7 +73,7 @@ module Lib
         end
         task.progress(40) if task # loaded actual values
         
-        prediction_dataset = OpenTox::Dataset.find prediction_dataset_uri
+        prediction_dataset = OpenTox::Dataset.find prediction_dataset_uri,subjectid
         raise "prediction dataset not found: '"+prediction_dataset_uri.to_s+"'" unless prediction_dataset
         
         # TODO: remove LAZAR_PREDICTION_DATASET_HACK
diff --git a/report/report_application.rb b/report/report_application.rb
index b02b780..9fcf871 100755
--- a/report/report_application.rb
+++ b/report/report_application.rb
@@ -1,20 +1,8 @@
 require "report/environment.rb"
 
 def perform
-  begin
-    @@report_service = Reports::ReportService.instance( url_for("/report", :full) ) unless defined?@@report_service  
-    yield( @@report_service )
-  rescue Reports::NotFound => ex
-    halt 404, ex.message
-  rescue Reports::BadRequest => ex
-    halt 400, ex.message
-  rescue Exception => ex
-    #LOGGER.error(ex.message)
-    LOGGER.error "report error: "+ex.message
-    LOGGER.error ": "+ex.backtrace.join("\n")
-    raise ex # sinatra returns 501
-    #halt 500, ex.message 
-  end
+  @@report_service = Reports::ReportService.instance( url_for("/report", :full) ) unless defined?@@report_service  
+  yield( @@report_service )
 end
 
 def get_docbook_resource(filepath)
@@ -104,11 +92,11 @@ get '/report/:type/:id' do
   end
 end
 
-get '/report/:type/:id/:resource' do
-  #hack: using request.env['REQUEST_URI'].split("/")[-1] instead of params[:resource] because the file extension is lost
+OpenTox::Authorization.whitelist( Regexp.new("/report/.*/[0-9]+/.*"),"GET")
 
+get '/report/:type/:id/:resource' do
   perform do |rs|
-    filepath = rs.get_report_resource(params[:type],params[:id],request.env['REQUEST_URI'].split("/")[-1])
+    filepath = rs.get_report_resource(params[:type],params[:id],params[:resource])
     types = MIME::Types.type_for(filepath)
     content_type(types[0].content_type) if types and types.size>0 and types[0]
     result = body(File.new(filepath))
diff --git a/report/report_factory.rb b/report/report_factory.rb
index 11e9bfa..a5234a3 100755
--- a/report/report_factory.rb
+++ b/report/report_factory.rb
@@ -59,7 +59,7 @@ module Reports::ReportFactory
   
   def self.create_report_validation(validation_set, task=nil)
     
-    raise Reports::BadRequest.new("num validations is not equal to 1") unless validation_set.size==1
+    raise OpenTox::BadRequestError.new("num validations is not equal to 1") unless validation_set.size==1
     val = validation_set.validations[0]
     pre_load_predictions( validation_set, OpenTox::SubTask.create(task,0,80) )
 
@@ -84,14 +84,14 @@ module Reports::ReportFactory
   
   def self.create_report_crossvalidation(validation_set, task=nil)
     
-    raise Reports::BadRequest.new("num validations is not >1") unless validation_set.size>1
-    raise Reports::BadRequest.new("crossvalidation-id not unique and != nil: "+
+    raise OpenTox::BadRequestError.new("num validations is not >1") unless validation_set.size>1
+    raise OpenTox::BadRequestError.new("crossvalidation-id not unique and != nil: "+
       validation_set.get_values(:crossvalidation_id,false).inspect) if validation_set.unique_value(:crossvalidation_id)==nil
     validation_set.load_cv_attributes
-    raise Reports::BadRequest.new("num validations ("+validation_set.size.to_s+") is not equal to num folds ("+
+    raise OpenTox::BadRequestError.new("num validations ("+validation_set.size.to_s+") is not equal to num folds ("+
       validation_set.unique_value(:num_folds).to_s+")") unless validation_set.unique_value(:num_folds)==validation_set.size
-    raise Reports::BadRequest.new("num different folds is not equal to num validations") unless validation_set.num_different_values(:crossvalidation_fold)==validation_set.size
-    raise Reports::BadRequest.new("validations must have unique feature type, i.e. must be either all regression, "+
+    raise OpenTox::BadRequestError.new("num different folds is not equal to num validations") unless validation_set.num_different_values(:crossvalidation_fold)==validation_set.size
+    raise OpenTox::BadRequestError.new("validations must have unique feature type, i.e. must be either all regression, "+
       +"or all classification validations") unless validation_set.unique_feature_type  
     pre_load_predictions( validation_set, OpenTox::SubTask.create(task,0,80) )
     
@@ -125,16 +125,16 @@ module Reports::ReportFactory
   def self.create_report_compare_algorithms(validation_set, task=nil)
     
     #validation_set.to_array([:test_dataset_uri, :model_uri, :algorithm_uri], false).each{|a| puts a.inspect}
-    raise Reports::BadRequest.new("num validations is not >1") unless validation_set.size>1
-    raise Reports::BadRequest.new("validations must have unique feature type, i.e. must be either all regression, "+
+    raise OpenTox::BadRequestError.new("num validations is not >1") unless validation_set.size>1
+    raise OpenTox::BadRequestError.new("validations must have unique feature type, i.e. must be either all regression, "+
       +"or all classification validations") unless validation_set.unique_feature_type
-    raise Reports::BadRequest.new("number of different algorithms <2: "+
+    raise OpenTox::BadRequestError.new("number of different algorithms <2: "+
       validation_set.get_values(:algorithm_uri).inspect) if validation_set.num_different_values(:algorithm_uri)<2
       
     if validation_set.has_nil_values?(:crossvalidation_id)
-      raise Reports::BadRequest.new("algorithm comparison for non crossvalidation not yet implemented")
+      raise OpenTox::BadRequestError.new("algorithm comparison for non crossvalidation not yet implemented")
     else
-      raise Reports::BadRequest.new("num different cross-validation-ids <2") if validation_set.num_different_values(:crossvalidation_id)<2
+      raise OpenTox::BadRequestError.new("num different cross-validation-ids <2") if validation_set.num_different_values(:crossvalidation_id)<2
       validation_set.load_cv_attributes
       compare_algorithms_crossvalidation(validation_set, task)
     end
@@ -194,7 +194,7 @@ module Reports::ReportFactory
       end
       
     when "regression"
-      raise Reports::BadRequest.new("algorithm comparison for regression not yet implemented")
+      raise OpenTox::BadRequestError.new("algorithm comparison for regression not yet implemented")
     end
     task.progress(100) if task
     report
diff --git a/report/report_format.rb b/report/report_format.rb
index baf7434..98dea39 100644
--- a/report/report_format.rb
+++ b/report/report_format.rb
@@ -23,7 +23,7 @@ module Reports::ReportFormat
     when /application\/x-yaml|\*\/\*/
       "application/x-yaml"
     else
-      raise Reports::BadRequest.new("Accept header '"+accept_header_value.to_s+
+      raise OpenTox::BadRequestError.new("Accept header '"+accept_header_value.to_s+
         "' not supported, supported types are "+
         "text/html"+", "+
         "application/rdf+xml"+", "+
diff --git a/report/report_persistance.rb b/report/report_persistance.rb
index 808547d..df4930c 100755
--- a/report/report_persistance.rb
+++ b/report/report_persistance.rb
@@ -100,7 +100,7 @@ class Reports::FileReportPersistance < Reports::ReportPersistance
     report_dir = report_directory(type, id)
     raise_report_not_found(type, id) unless File.directory?(report_dir)
     file_path = report_dir+"/"+resource.to_s
-    raise Reports::NotFound.new("resource not found, resource: '"+resource.to_s+"', type:'"+type.to_s+"', id:'"+id.to_s+"'") unless File.exist?(file_path)
+    raise OpenTox::NotFoundError.new("resource not found, resource: '"+resource.to_s+"', type:'"+type.to_s+"', id:'"+id.to_s+"'") unless File.exist?(file_path)
     return file_path
   end
   
@@ -162,7 +162,7 @@ class Reports::FileReportPersistance < Reports::ReportPersistance
   
   private
   def raise_report_not_found(type, id)
-    raise Reports::NotFound.new("report not found, type:'"+type.to_s+"', id:'"+id.to_s+"'")
+    raise OpenTox::NotFoundError.new("report not found, type:'"+type.to_s+"', id:'"+id.to_s+"'")
   end
   
   def type_directory(type)
@@ -270,11 +270,11 @@ module Reports
     def get_report(type, id, format, force_formating, params)
       
       report = ReportData.first({:id => id, :report_type => type})
-      raise Reports::NotFound.new("Report with id='"+id.to_s+"' and type='"+type.to_s+"' not found.") unless report
+      raise OpenTox::NotFoundError.new("Report with id='"+id.to_s+"' and type='"+type.to_s+"' not found.") unless report
 #      begin
 #        report = ReportData.find(:first, :conditions => {:id => id, :report_type => type})
 #      rescue ActiveRecord::RecordNotFound
-#        raise Reports::NotFound.new("Report with id='"+id.to_s+"' and type='"+type.to_s+"' not found.")
+#        raise OpenTox::NotFoundError.new("Report with id='"+id.to_s+"' and type='"+type.to_s+"' not found.")
 #      end
   
       case format
@@ -291,11 +291,11 @@ module Reports
 #      begin
 #        report = ReportData.find(:first, :conditions => {:id => id, :report_type => type})
 #      rescue ActiveRecord::RecordNotFound
-#        raise Reports::NotFound.new("Report with id='"+id.to_s+"' and type='"+type.to_s+"' not found.")
+#        raise OpenTox::NotFoundError.new("Report with id='"+id.to_s+"' and type='"+type.to_s+"' not found.")
 #      end
 #      ReportData.delete(id)
       report = ReportData.first({:id => id, :report_type => type})
-      raise Reports::NotFound.new("Report with id='"+id.to_s+"' and type='"+type.to_s+"' not found.") unless report
+      raise OpenTox::NotFoundError.new("Report with id='"+id.to_s+"' and type='"+type.to_s+"' not found.") unless report
       report.destroy
       if (subjectid)
         begin
diff --git a/report/report_service.rb b/report/report_service.rb
index dd1f6b3..91eefe8 100644
--- a/report/report_service.rb
+++ b/report/report_service.rb
@@ -66,10 +66,10 @@ module Reports
       check_report_type(type)
       
       # step1: load validations
-      raise Reports::BadRequest.new("validation_uris missing") unless validation_uris
+      raise OpenTox::BadRequestError.new("validation_uris missing") unless validation_uris
       LOGGER.debug "validation_uri(s): '"+validation_uris.inspect+"'"
-      validation_set = Reports::ValidationSet.new(validation_uris)
-      raise Reports::BadRequest.new("cannot get validations from validation_uris '"+validation_uris.inspect+"'") unless validation_set and validation_set.size > 0
+      validation_set = Reports::ValidationSet.new(validation_uris, subjectid)
+      raise OpenTox::BadRequestError.new("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
       
@@ -182,30 +182,8 @@ module Reports
     end
     
     def check_report_type(type)
-     raise Reports::NotFound.new("report type not found '"+type.to_s+"'") unless Reports::ReportFactory::REPORT_TYPES.index(type)
+     raise OpenTox::NotFoundError.new("report type not found '"+type.to_s+"'") unless Reports::ReportFactory::REPORT_TYPES.index(type)
     end
     
   end
 end
-
-class Reports::LoggedException < Exception
-  
-  def initialize(message)
-    super(message)
-    LOGGER.error(message)
-  end
-  
-end
-
-# corresponds to 400
-#
-class Reports::BadRequest < Reports::LoggedException
-  
-end
-
-# corresponds to 404
-#
-class Reports::NotFound < Reports::LoggedException
-  
-end
-
diff --git a/report/report_test.rb b/report/report_test.rb
index 1f3e524..571d6d8 100755
--- a/report/report_test.rb
+++ b/report/report_test.rb
@@ -148,7 +148,7 @@ end
 #      assert types.is_a?(String)
 #      assert types.split("\n").size == Reports::ReportFactory::REPORT_TYPES.size
 #      #Reports::ReportFactory::REPORT_TYPES.each{|t| rep.get_all_reports(t)}
-#      #assert_raise(Reports::NotFound){rep.get_all_reports("osterhase")}
+#      #assert_raise(OpenTox::NotFoundError){rep.get_all_reports("osterhase")}
 #      
 #      ### using ot_mock_layer (reporting component does not rely on ot validation webservice)
 #      
@@ -156,11 +156,11 @@ end
 #      #Reports::Validation.reset_validation_access
 #      
 ##      create_report(rep, "validation_uri_1", "validation")
-##      assert_raise(Reports::BadRequest){create_report(rep, ["validation_uri_1","validation_uri_2"], "validation")}
+##      assert_raise(OpenTox::BadRequestError){create_report(rep, ["validation_uri_1","validation_uri_2"], "validation")}
 ##      
 ##      create_report(rep, "crossvalidation_uri_1", "crossvalidation")
 ##      create_report(rep, ["validation_uri_1"]*Reports::OTMockLayer::NUM_FOLDS, "crossvalidation")
-##      assert_raise(Reports::BadRequest){create_report(rep, ["validation_uri_1"]*(Reports::OTMockLayer::NUM_FOLDS-1), "crossvalidation")}
+##      assert_raise(OpenTox::BadRequestError){create_report(rep, ["validation_uri_1"]*(Reports::OTMockLayer::NUM_FOLDS-1), "crossvalidation")}
 ##      
 ##      create_report(rep, ["crossvalidation_uri_1"]* (Reports::OTMockLayer::NUM_DATASETS * Reports::OTMockLayer::NUM_ALGS), "algorithm_comparison")
 ##      create_report(rep, ["validation_uri_1"]* (Reports::OTMockLayer::NUM_DATASETS * Reports::OTMockLayer::NUM_ALGS * Reports::OTMockLayer::NUM_FOLDS), "algorithm_comparison")
@@ -229,11 +229,11 @@ end
 #    
 #    #puts "created report with id "+id.to_s
 #    
-#    #assert_raise(Reports::BadRequest){report_service.get_report(type, id, "weihnachtsmann")}
+#    #assert_raise(OpenTox::BadRequestError){report_service.get_report(type, id, "weihnachtsmann")}
 #    
 #    report_service.get_report(type, id, "text/html")
 #    #report_service.get_report(type, id, "application/pdf")
-#    #assert_raise(Reports::NotFound){report_service.delete_report(type, 877658)}
+#    #assert_raise(OpenTox::NotFoundError){report_service.delete_report(type, 877658)}
 #
 ##      rep.delete_report(type, id)
 #  end
diff --git a/report/util.rb b/report/util.rb
index 9844fd8..ca5f3cc 100644
--- a/report/util.rb
+++ b/report/util.rb
@@ -75,10 +75,10 @@ module Reports::Util
   #
   def self.check_group_matching( grouped_objects, match_attributes )
     
-    raise Reports::BadRequest.new("less then 2 groups, no matching possible") if grouped_objects.size<2
+    raise OpenTox::BadRequestError.new("less then 2 groups, no matching possible") if grouped_objects.size<2
     first_group = grouped_objects[0]
     other_groups = grouped_objects[1..-1].collect{ |g| g.collect{|o| o }} 
-    other_groups.each{ |g| raise Reports::BadRequest.new("groups are not equally sized, matching impossible") if g.size != first_group.size } 
+    other_groups.each{ |g| raise OpenTox::BadRequestError.new("groups are not equally sized, matching impossible") if g.size != first_group.size } 
     
     first_group.each do |o|
       
@@ -94,7 +94,7 @@ module Reports::Util
             break
           end
         end
-        raise Reports::BadRequest.new("no match found for "+inspect_attributes(o, match_attributes)) unless match
+        raise OpenTox::BadRequestError.new("no match found for "+inspect_attributes(o, match_attributes)) unless match
       end
     end
   end
diff --git a/report/validation_access.rb b/report/validation_access.rb
index 170cdfd..9c45165 100755
--- a/report/validation_access.rb
+++ b/report/validation_access.rb
@@ -8,7 +8,7 @@ class Reports::ValidationAccess
 
   # initialize Reports::Validation object with data from Lib:Validation object
   #  
-  def init_validation(validation, uri)
+  def init_validation(validation, uri, subjectid=nil)
     raise "not implemented"
   end
   
@@ -20,13 +20,13 @@ class Reports::ValidationAccess
   
   # yields predictions (Lib::OTPredictions) if available 
   #
-  def get_predictions(validation, task=nil)
+  def get_predictions(validation, subjectid=nil, task=nil)
     raise "not implemented"
   end
   
   # replaces crossvalidations uris with corresponding validation uris, in-/output: array
   #
-  def resolve_cv_uris(validation_uris)
+  def resolve_cv_uris(validation_uris,subjectid=nil)
     raise "not implemented"
   end
   
@@ -37,11 +37,11 @@ class Reports::ValidationAccess
   end
   
   # is validation classification/regression?
-  def feature_type(validation)
+  def feature_type(validation, subjectid=nil)
     raise "not implemented"
   end
   
-  def predicted_variable(validation)
+  def predicted_variable(validation, subjectid=nil)
     raise "not implemented"
   end
   
@@ -53,20 +53,23 @@ class Reports::ValidationDB < Reports::ValidationAccess
 #    @model_store = {}
 #  end
   
-  def resolve_cv_uris(validation_uris)
+  def resolve_cv_uris(validation_uris, subjectid=nil)
     res = []
     validation_uris.each do |u|
       if u.to_s =~ /.*\/crossvalidation\/[0-9]+/
         cv_id = u.split("/")[-1].to_i
         cv = nil
-        begin
-          #cv = Lib::Crossvalidation.find( cv_id )
-          cv = Lib::Crossvalidation.get( cv_id )
-        rescue => ex
-          raise "could not access crossvalidation with id "+validation_id.to_s+", error-msg: "+ex.message
-        end
-        raise Reports::BadRequest.new("crossvalidation with id '"+cv_id.to_s+"' not found") unless cv
-        raise Reports::BadRequest.new("crossvalidation with id '"+cv_id.to_s+"' not finished") unless cv.finished
+        
+        raise OpenTox::NotAuthorizedError.new "Not authorized: GET "+u.to_s if
+          subjectid and !OpenTox::Authorization.authorized?(u,"GET",subjectid)
+#        begin
+#          #cv = Lib::Crossvalidation.find( cv_id )
+#        rescue => ex
+#          raise "could not access crossvalidation with id "+validation_id.to_s+", error-msg: "+ex.message
+#        end
+        cv = Lib::Crossvalidation.get( cv_id )
+        raise OpenTox::NotFoundError.new "crossvalidation with id "+cv_id.to_s+" not found" unless cv
+        raise OpenTox::BadRequestError.new("crossvalidation with id '"+cv_id.to_s+"' not finished") unless cv.finished
         #res += Lib::Validation.find( :all, :conditions => { :crossvalidation_id => cv_id } ).collect{|v| v.validation_uri.to_s}
         res += Lib::Validation.all( :crossvalidation_id => cv_id ).collect{|v| v.validation_uri.to_s }
       else
@@ -76,21 +79,18 @@ class Reports::ValidationDB < Reports::ValidationAccess
     res
   end
   
-  def init_validation(validation, uri)
+  def init_validation(validation, uri, subjectid=nil)
   
-    raise Reports::BadRequest.new "not a validation uri: "+uri.to_s unless uri =~ /.*\/[0-9]+/
+    raise OpenTox::BadRequestError.new "not a validation uri: "+uri.to_s unless uri =~ /.*\/[0-9]+/
     validation_id = uri.split("/")[-1]
-    raise Reports::BadRequest.new "invalid validation id "+validation_id.to_s unless validation_id!=nil and 
+    raise OpenTox::BadRequestError.new "invalid validation id "+validation_id.to_s unless validation_id!=nil and 
       (validation_id.to_i > 0 || validation_id.to_s=="0" )
     v = nil
-    begin
-      #v = Lib::Validation.find(validation_id)
-      v = Lib::Validation.get(validation_id)
-    rescue => ex
-      raise "could not access validation with id "+validation_id.to_s+", error-msg: "+ex.message
-    end
-    raise Reports::BadRequest.new "no validation found with id "+validation_id.to_s unless v #+" and uri "+uri.to_s unless v
-    raise Reports::BadRequest.new "validation with id "+validation_id.to_s+" is not finished yet" unless v.finished
+    raise OpenTox::NotAuthorizedError.new "Not authorized: GET "+uri.to_s if
+      subjectid and !OpenTox::Authorization.authorized?(uri,"GET",subjectid)
+    v = Lib::Validation.get(validation_id)
+    raise OpenTox::NotFoundError.new "validation with id "+validation_id.to_s+" not found" unless v
+    raise OpenTox::BadRequestError.new "validation with id "+validation_id.to_s+" is not finished yet" unless v.finished
     
     (Lib::VAL_PROPS + Lib::VAL_CV_PROPS).each do |p|
       validation.send("#{p.to_s}=".to_sym, v.send(p))
@@ -107,32 +107,33 @@ class Reports::ValidationDB < Reports::ValidationAccess
     
     #cv = Lib::Crossvalidation.find(validation.crossvalidation_id)
     cv = Lib::Crossvalidation.get(validation.crossvalidation_id)
-    raise Reports::BadRequest.new "no crossvalidation found with id "+validation.crossvalidation_id.to_s unless cv
+    raise OpenTox::BadRequestError.new "no crossvalidation found with id "+validation.crossvalidation_id.to_s unless cv
     
     Lib::CROSS_VAL_PROPS.each do |p|
       validation.send("#{p.to_s}=".to_sym, cv[p])        
     end
   end
 
-  def get_predictions(validation, task=nil)
+  def get_predictions(validation, subjectid=nil, task=nil)
     Lib::OTPredictions.new( validation.feature_type, validation.test_dataset_uri, 
       validation.test_target_dataset_uri, validation.prediction_feature, validation.prediction_dataset_uri, 
-      validation.predicted_variable, task)
+      validation.predicted_variable, subjectid, task)
   end
   
   def get_class_domain( validation )
     OpenTox::Feature.new( validation.prediction_feature ).domain
   end
   
-  def feature_type( validation )
-    OpenTox::Model::Generic.new(validation.model_uri).feature_type
+  def feature_type( validation, subjectid=nil )
+    raise "subjectid is nil" unless subjectid
+    OpenTox::Model::Generic.new(validation.model_uri).feature_type(subjectid)
     #get_model(validation).classification?
   end
   
-  def predicted_variable(validation)
+  def predicted_variable(validation, subjectid=nil)
     raise "cannot derive model depended props for merged validations" if Lib::MergeObjects.merged?(validation)
-    model = OpenTox::Model::Generic.find(validation.model_uri)
-    raise Reports::NotFound.new "model not found '"+validation.model_uri+"'" unless model
+    model = OpenTox::Model::Generic.find(validation.model_uri, subjectid)
+    raise OpenTox::NotFoundError.new "model not found '"+validation.model_uri+"'" unless model
     model.metadata[OT.predictedVariables]
     #get_model(validation).predictedVariables
   end
@@ -164,7 +165,7 @@ class Reports::ValidationWebservice < Reports::ValidationAccess
         begin
           vali_uri_list = RestClientWrapper.get uri
         rescue => ex
-          raise Reports::BadRequest.new "cannot get validations for cv at '"+uri.to_s+"', error msg: "+ex.message
+          raise OpenTox::BadRequestError.new "cannot get validations for cv at '"+uri.to_s+"', error msg: "+ex.message
         end
         res += vali_uri_list.split("\n")
       else
@@ -180,7 +181,7 @@ class Reports::ValidationWebservice < Reports::ValidationAccess
     begin
       data = YAML.load(RestClient.get uri)
     rescue => ex
-      raise Reports::BadRequest.new "cannot get validation at '"+uri.to_s+"', error msg: "+ex.message
+      raise OpenTox::BadRequestError.new "cannot get validation at '"+uri.to_s+"', error msg: "+ex.message
     end
   
     Lib::VAL_PROPS.each do |p|
@@ -205,7 +206,7 @@ class Reports::ValidationWebservice < Reports::ValidationAccess
     begin
       data = YAML.load(RestClient.get validation.crossvalidation_uri)
     rescue => ex
-      raise Reports::BadRequest.new "cannot get crossvalidation at '"+validation.crossvalidation_uri.to_s+"', error msg: "+ex.message
+      raise OpenTox::BadRequestError.new "cannot get crossvalidation at '"+validation.crossvalidation_uri.to_s+"', error msg: "+ex.message
     end
     
     Lib::CROSS_VAL_PROPS.each do |p|
@@ -213,7 +214,7 @@ class Reports::ValidationWebservice < Reports::ValidationAccess
     end
   end
 
-  def get_predictions(validation, task=nil)
+  def get_predictions(validation, subjectid=nil, task=nil)
     Lib::Predictions.new( validation.prediction_feature, validation.test_dataset_uri, validation.prediction_dataset_uri)
   end
 end
diff --git a/report/validation_data.rb b/report/validation_data.rb
index c4eed12..0dd63ee 100755
--- a/report/validation_data.rb
+++ b/report/validation_data.rb
@@ -76,8 +76,10 @@ module Reports
   
     attr_reader :predictions
     
-    def initialize(uri = nil)
-      @@validation_access.init_validation(self, uri) if uri
+    def initialize(uri = nil, subjectid = nil)
+      @@validation_access.init_validation(self, uri, subjectid) if uri
+      @subjectid = subjectid
+      #raise "subjectid is nil" unless subjectid
     end
   
     # returns/creates predictions, cache to save rest-calls/computation time
@@ -95,7 +97,7 @@ module Reports
           task.progress(100) if task
           nil
         else
-          @predictions = @@validation_access.get_predictions( self, task )
+          @predictions = @@validation_access.get_predictions( self, @subjectid, task )
         end
       end
     end
@@ -111,12 +113,12 @@ module Reports
     #
     def feature_type
       return @feature_type if @feature_type!=nil
-      @feature_type = @@validation_access.feature_type(self) 
+      @feature_type = @@validation_access.feature_type(self, @subjectid) 
     end
     
     def predicted_variable
       return @predicted_variable if @predicted_variable!=nil
-      @predicted_variable = @@validation_access.predicted_variable(self) 
+      @predicted_variable = @@validation_access.predicted_variable(self, @subjectid) 
     end
     
     # loads all crossvalidation attributes, of the corresponding cv into this object 
@@ -156,11 +158,11 @@ module Reports
   #
   class ValidationSet
     
-    def initialize(validation_uris = nil)
+    def initialize(validation_uris=nil, subjectid=nil)
       @unique_values = {}
       validation_uris = Reports::Validation.resolve_cv_uris(validation_uris) if validation_uris
       @validations = Array.new
-      validation_uris.each{|u| @validations.push(Reports::Validation.new(u))} if validation_uris
+      validation_uris.each{|u| @validations.push(Reports::Validation.new(u, subjectid))} if validation_uris
     end
 
   
diff --git a/test/test_examples.rb b/test/test_examples.rb
index 45d7035..192f1a4 100755
--- a/test/test_examples.rb
+++ b/test/test_examples.rb
@@ -355,7 +355,18 @@ module ValidationExamples
   end
   
   ########################################################################################################
-    
+ 
+  
+  class NtuaModel < ModelValidation
+    def initialize
+      @model_uri = "http://opentox.ntua.gr:4000/model/0d8a9a27-3481-4450-bca1-d420a791de9d" 
+      @test_dataset_uri = "http://apps.ideaconsult.net:8080/ambit2/dataset/54"
+      #@prediction_feature=http://apps.ideaconsult.net:8080/ambit2/feature/22200
+    end
+  end
+  
+   ########################################################################################################
+  
   @@list = {
       "1" => [ LazarHamsterSplit, MajorityHamsterSplit ],
       "1a" => [ LazarHamsterSplit ],
@@ -403,6 +414,8 @@ module ValidationExamples
       
       "14a" =>  [ LazarEPAFHMCrossvalidation ],
       "14b" =>  [ MajorityEPAFHMCrossvalidation ],
+      
+      "15a" =>  [ NtuaModel ],
     }
   
   def self.list
diff --git a/test/test_examples_util.rb b/test/test_examples_util.rb
index 9f11fe7..02d5921 100755
--- a/test/test_examples_util.rb
+++ b/test/test_examples_util.rb
@@ -89,8 +89,9 @@ module ValidationExamples
     def self.wait(uri)
       if uri.task_uri?
         task = OpenTox::Task.find(uri.to_s.chomp)
-        task.wait_for_completion
-        raise "task failed: "+uri.to_s+", error is:\n"+task.description.to_s if task.error?
+        task.wait_for_completion nil,5
+        #raise "task failed: "+uri.to_s+", description: '"+task.description.to_s+"'" if task.error?
+        LOGGER.error "task failed:\n"+task.errorReport.to_yaml if task.error?
         uri = task.result_uri
       end
       uri
@@ -366,6 +367,10 @@ module ValidationExamples
     def opt_params
       [ :prediction_feature, :test_target_dataset_uri ]
     end
+    
+    def validation_type
+      "test_set_validation"
+    end    
   end
   
   class TrainingTestValidation < ValidationExample
diff --git a/validation/validation_service.rb b/validation/validation_service.rb
index eb9ecff..fa638cf 100755
--- a/validation/validation_service.rb
+++ b/validation/validation_service.rb
@@ -129,7 +129,7 @@ module Validation
       
       #model = OpenTox::Model::PredictionModel.find(self.model_uri)
       #raise OpenTox::NotFoundError.new "model not found: "+self.model_uri.to_s unless model
-      model = OpenTox::Model::Generic.find(self.model_uri)
+      model = OpenTox::Model::Generic.find(self.model_uri, self.subjectid)
       raise OpenTox::NotFoundError.new "model not found: "+self.model_uri.to_s unless model
       
       unless self.algorithm_uri
@@ -173,7 +173,7 @@ module Validation
       
       #model = OpenTox::Model::PredictionModel.find(self.model_uri) if model==nil and self.model_uri
       #raise OpenTox::NotFoundError.new "model not found: "+self.model_uri.to_s unless model
-      model = OpenTox::Model::Generic.find(self.model_uri) if model==nil and self.model_uri
+      model = OpenTox::Model::Generic.find(self.model_uri, self.subjectid) if model==nil and self.model_uri
       raise OpenTox::NotFoundError.new "model not found: "+self.model_uri.to_s unless model
       
       dependentVariables = model.metadata[OT.dependentVariables]
@@ -198,7 +198,7 @@ module Validation
       LOGGER.debug "computing prediction stats"
       prediction = Lib::OTPredictions.new( feature_type, 
         self.test_dataset_uri, self.test_target_dataset_uri, self.prediction_feature, 
-        self.prediction_dataset_uri, predicted_feature, OpenTox::SubTask.create(task, 0, 80) )
+        self.prediction_dataset_uri, predicted_feature, self.subjectid, OpenTox::SubTask.create(task, 0, 80) )
       #reading datasets and computing the main stats is 80% the work 
       
       unless dry_run
@@ -338,7 +338,7 @@ module Validation
       
       raise "random seed not set "+self.inspect unless self.random_seed
       LOGGER.debug "creating datasets for crossvalidation"
-      orig_dataset = OpenTox::Dataset.find(self.dataset_uri)
+      orig_dataset = OpenTox::Dataset.find(self.dataset_uri,self.subjectid)
       raise OpenTox::NotFoundError.new "Dataset not found: "+self.dataset_uri.to_s unless orig_dataset
       
       shuffled_compounds = orig_dataset.compounds.shuffle( self.random_seed )
@@ -448,7 +448,7 @@ module Validation
       
       random_seed=1 unless random_seed
       
-      orig_dataset = OpenTox::Dataset.find orig_dataset_uri
+      orig_dataset = OpenTox::Dataset.find orig_dataset_uri,subjectid
       orig_dataset.load_all
       raise OpenTox::NotFoundError.new "Dataset not found: "+orig_dataset_uri.to_s unless orig_dataset
       if prediction_feature
@@ -513,7 +513,7 @@ module Validation
       task.progress(100) if task
       
       if ENV['RACK_ENV'] =~ /test|debug/
-        training_dataset = OpenTox::Dataset.find result[:training_dataset_uri]
+        training_dataset = OpenTox::Dataset.find result[:training_dataset_uri],subjectid
         raise OpenTox::NotFoundError.new "Training dataset not found: '"+result[:training_dataset_uri].to_s+"'" unless training_dataset
         training_dataset.load_all
         value_count = 0
@@ -521,7 +521,8 @@ module Validation
           value_count += training_dataset.data_entries[c][prediction_feature].size
         end
         raise  "training compounds error" unless value_count==training_compounds.size
-        raise OpenTox::NotFoundError.new "Test dataset not found: '"+result[:test_dataset_uri].to_s+"'" unless OpenTox::Dataset.find result[:test_dataset_uri]
+        raise OpenTox::NotFoundError.new "Test dataset not found: '"+result[:test_dataset_uri].to_s+"'" unless 
+          OpenTox::Dataset.find result[:test_dataset_uri], subjectid
       end
       LOGGER.debug "bootstrapping done, training dataset: '"+result[:training_dataset_uri].to_s+"', test dataset: '"+result[:test_dataset_uri].to_s+"'"
       
@@ -535,8 +536,8 @@ module Validation
       split_ratio=0.67 unless split_ratio
       random_seed=1 unless random_seed
       
-      orig_dataset = OpenTox::Dataset.find orig_dataset_uri
-      orig_dataset.load_all
+      orig_dataset = OpenTox::Dataset.find orig_dataset_uri, subjectid
+      orig_dataset.load_all subjectid
       raise OpenTox::NotFoundError.new "Dataset not found: "+orig_dataset_uri.to_s unless orig_dataset
       raise OpenTox::NotFoundError.new "Split ratio invalid: "+split_ratio.to_s unless split_ratio and split_ratio=split_ratio.to_f
       raise OpenTox::NotFoundError.new "Split ratio not >0 and <1 :"+split_ratio.to_s unless split_ratio>0 && split_ratio<1
@@ -597,10 +598,11 @@ module Validation
       task.progress(100) if task  
       
       if ENV['RACK_ENV'] =~ /test|debug/
-        raise OpenTox::NotFoundError.new "Training dataset not found: '"+result[:training_dataset_uri].to_s+"'" unless OpenTox::Dataset.find result[:training_dataset_uri]
-        test_data = OpenTox::Dataset.find result[:test_dataset_uri]
+        raise OpenTox::NotFoundError.new "Training dataset not found: '"+result[:training_dataset_uri].to_s+"'" unless 
+          OpenTox::Dataset.find(result[:training_dataset_uri],subjectid)
+        test_data = OpenTox::Dataset.find result[:test_dataset_uri],subjectid
         raise OpenTox::NotFoundError.new "Test dataset not found: '"+result[:test_dataset_uri].to_s+"'" unless test_data 
-        test_data.load_compounds
+        test_data.load_compounds subjectid
         raise "Test dataset num coumpounds != "+(compounds.size-split-1).to_s+", instead: "+
           test_data.compounds.size.to_s+"\n"+test_data.to_yaml unless test_data.compounds.size==(compounds.size-1-split)
       end
diff --git a/validation/validation_test.rb b/validation/validation_test.rb
index 3138252..603b270 100755
--- a/validation/validation_test.rb
+++ b/validation/validation_test.rb
@@ -26,11 +26,16 @@ if AA_SERVER
   raise "could not log in" unless SUBJECTID
   puts "logged in: "+SUBJECTID.to_s
 else
+  puts "AA disabled"
   SUBJECTID = nil
 end
 
 #Rack::Test::DEFAULT_HOST = "local-ot" #"/validation"
 module Sinatra
+  
+  set :raise_errors, false
+  set :show_exceptions, false
+
   module UrlForHelper
     BASE = "http://local-ot/validation"
     def url_for url_fragment, mode=:path_only
@@ -53,7 +58,8 @@ class ValidationTest < Test::Unit::TestCase
     begin
       $test_case = self
       
-      #get "/1",nil,'HTTP_ACCEPT' => "text/html" 
+#      get "/19999",nil,'HTTP_ACCEPT' => "text/html"
+#      exit
 #       
 #      get "/234234232341",nil,'HTTP_ACCEPT' => "application/x-yaml"
 #      puts last_response.body
@@ -131,13 +137,23 @@ class ValidationTest < Test::Unit::TestCase
       #run_test("13a","http://local-ot/validation/39",nil,false) #,"http://local-ot/validation/28")#,"http://local-ot/validation/394");
       
       #puts OpenTox::Authorization.list_policy_uris(SUBJECTID).inspect
+      
+      #puts OpenTox::Authorization.list_policy_uris(SUBJECTID).inspect
 
-      #run_test("1b",nil,nil,false,{:dataset_uri=>"http://local-ot/dataset/45", :prediction_feature => "http://local-ot/dataset/45/feature/Hamster%20Carcinogenicity"})
+      run_test("14a",nil,nil,false) #,{:dataset_uri=>"http://local-ot/dataset/45", :prediction_feature => "http://local-ot/dataset/45/feature/Hamster%20Carcinogenicity"})
       
       #get "/12123123123123123"
-      get "/chain"
-      #get "/examples"
-      puts last_response.body
+      #get "/chain"
+      
+      #OpenTox::RestClientWrapper.get("http://local-ot/validation/task-error")
+      #get "/error",nil,'HTTP_ACCEPT' => "application/rdf+xml"
+      #puts ""
+      #puts ""
+      #puts last_response.body 
+      #exit
+      
+#      get "/error"
+#      puts last_response.body
 
       #delete "/1",:subjectid=>SUBJECTID
       
@@ -170,7 +186,7 @@ class ValidationTest < Test::Unit::TestCase
   
   def run_test(select=nil, validation_uri=nil, report_uri=nil, delete=false, overwrite={})
     
-    if AA_SERVER && delete
+    if AA_SERVER && SUBJECTID && delete
       policies_before = OpenTox::Authorization.list_policy_uris(SUBJECTID)
     end
     
@@ -191,17 +207,17 @@ class ValidationTest < Test::Unit::TestCase
           ex.validate
           LOGGER.debug "validation done '"+ex.validation_uri.to_s+"'"
         end
-#        ex.report_uri = report_uri
-#        unless ex.report_uri
-#          ex.report
-#        end
+        ex.report_uri = report_uri
+        unless ex.report_uri
+          ex.report
+        end
         ##ex.verify_yaml
         ##ex.compare_yaml_vs_rdf
         ex.delete if delete
       end
     end
     
-    if AA_SERVER && delete
+    if AA_SERVER && SUBJECTID && delete
       policies_after= OpenTox::Authorization.list_policy_uris(SUBJECTID)
       diff = policies_after.size - policies_before.size
       if (diff != 0)