opentox-ruby 0.0.2 → 1.0.0

data/lib/parser.rb

@@ -29,22 +29,37 @@ module OpenTox
 
       # Read metadata from opentox service
       # @return [Hash] Object metadata
-      def load_metadata
-
-        if @dataset
-          uri = File.join(@uri,"metadata")
+      def load_metadata(subjectid=nil)
+        # avoid using rapper directly because of 2 reasons:
+        # * http errors wont be noticed
+        # * subjectid cannot be sent as header
+        ##uri += "?subjectid=#{CGI.escape(subjectid)}" if subjectid 
+        ## `rapper -i rdfxml -o ntriples #{uri} 2>/dev/null`.each_line do |line|
+        if File.exist?(@uri)
+          file = File.new(@uri)
         else
-          uri = @uri
+          file = Tempfile.new("ot-rdfxml")
+          if @dataset
+            # do not concat /metadata to uri string, this would not work for dataset/R401577?max=3 
+            uri = URI::parse(@uri)
+            uri.path = File.join(uri.path,"metadata")
+            uri = uri.to_s
+          else
+            uri = @uri
+          end
+          file.puts OpenTox::RestClientWrapper.get uri,{:subjectid => subjectid,:accept => "application/rdf+xml"},nil,false
+          file.close
+          to_delete = file.path
         end
-
         statements = []
         parameter_ids = []
-        `rapper -i rdfxml -o ntriples #{uri} 2>/dev/null`.each_line do |line|
+        `rapper -i rdfxml -o ntriples #{file.path} 2>/dev/null`.each_line do |line|
           triple = line.to_triple
           @metadata[triple[1]] = triple[2].split('^^').first if triple[0] == @uri and triple[1] != RDF['type']
           statements << triple 
           parameter_ids << triple[2] if triple[1] == OT.parameters
         end
+        File.delete(to_delete) if to_delete
         unless parameter_ids.empty?
           @metadata[OT.parameters] = []
           parameter_ids.each do |p|
@@ -55,10 +70,45 @@ module OpenTox
         end
         @metadata
       end
-
+      
+      # creates owl object from rdf-data
+      # @param [String] rdf
+      # @param [String] type of the info (e.g. OT.Task, OT.ErrorReport) needed to get the subject-uri
+      # @return [Owl] with uri and metadata set 
+      def self.from_rdf( rdf, type )
+        # write to file and read convert with rapper into tripples
+        file = Tempfile.new("ot-rdfxml")
+        file.puts rdf
+        file.close
+        #puts "cmd: rapper -i rdfxml -o ntriples #{file} 2>/dev/null"
+        triples = `rapper -i rdfxml -o ntriples #{file.path} 2>/dev/null`
+        
+        # load uri via type
+        uri = nil
+        triples.each_line do |line|
+          triple = line.to_triple
+          if triple[1] == RDF['type'] and triple[2]==type
+             raise "uri already set, two uris found with type: "+type.to_s if uri
+             uri = triple[0]
+          end
+        end
+        File.delete(file.path)
+        # load metadata
+        metadata = {}
+        triples.each_line do |line|
+          triple = line.to_triple
+          metadata[triple[1]] = triple[2].split('^^').first if triple[0] == uri and triple[1] != RDF['type']
+        end
+        owl = Owl::Generic.new(uri)
+        owl.metadata = metadata
+        owl
+      end
+      
       # Generic parser for all OpenTox classes
       class Generic
         include Owl
+        
+        attr_accessor :uri, :metadata
       end
 
       # OWL-DL parser for datasets
@@ -71,9 +121,9 @@ module OpenTox
         # Create a new OWL-DL dataset parser
         # @param uri Dataset URI 
         # @return [OpenTox::Parser::Owl::Dataset] OWL-DL parser
-        def initialize(uri)
+        def initialize(uri, subjectid=nil)
           super uri
-          @dataset = ::OpenTox::Dataset.new(@uri)
+          @dataset = ::OpenTox::Dataset.new(@uri, subjectid)
         end
 
         # Read data from dataset service. Files can be parsed by setting #uri to a filename (after initialization with a real URI)
@@ -87,12 +137,27 @@ module OpenTox
         #   dataset = parser.load_uri
         #   dataset.save
         # @return [Hash] Internal dataset representation
-        def load_uri
+        def load_uri(subjectid=nil)
+          
+          # avoid using rapper directly because of 2 reasons:
+          # * http errors wont be noticed
+          # * subjectid cannot be sent as header
+          ##uri += "?subjectid=#{CGI.escape(subjectid)}" if subjectid
+          ##`rapper -i rdfxml -o ntriples #{file} 2>/dev/null`.each_line do |line| 
+          if File.exist?(@uri)
+            file = File.new(@uri)
+          else
+            file = Tempfile.new("ot-rdfxml")
+            file.puts OpenTox::RestClientWrapper.get @uri,{:subjectid => subjectid,:accept => "application/rdf+xml"},nil,false
+            file.close
+            to_delete = file.path
+          end
+          
           data = {}
           feature_values = {}
           feature = {}
           other_statements = {}
-          `rapper -i rdfxml -o ntriples #{@uri} 2>/dev/null`.each_line do |line|
+          `rapper -i rdfxml -o ntriples #{file.path} 2>/dev/null`.each_line do |line|
             triple = line.chomp.split(' ',3)
             triple = triple[0..2].collect{|i| i.sub(/\s+.$/,'').gsub(/[<>"]/,'')}
             case triple[1] 
@@ -105,32 +170,62 @@ module OpenTox
               data[triple[0]] = {:compound => "", :values => []} unless data[triple[0]]
               data[triple[0]][:compound] = triple[2]  
             when /#{OT.feature}/i
-              feature[triple[0]] = triple[2] 
+              feature[triple[0]] = triple[2]
+            when /#{RDF.type}/i
+              if triple[2]=~/#{OT.Compound}/i and !data[triple[0]]
+                data[triple[0]] = {:compound => triple[0], :values => []} 
+              end
             else 
             end
           end
+          File.delete(to_delete) if to_delete
           data.each do |id,entry|
-            entry[:values].each do |value_id|
-              value = feature_values[value_id].split(/\^\^/).first # remove XSD.type
-              @dataset.add entry[:compound],feature[value_id],value
+            if entry[:values].size==0
+              # no feature values add plain compounds
+              @dataset.add_compound(entry[:compound])
+            else
+              entry[:values].each do |value_id|
+                split = feature_values[value_id].split(/\^\^/)
+                case split[-1]
+                when XSD.double, XSD.float 
+                  value = split.first.to_f
+                when XSD.boolean
+                  value = split.first=~/(?i)true/ ? true : false                
+                else
+                  value = split.first
+                end
+                @dataset.add entry[:compound],feature[value_id],value
+              end
             end
           end
-          load_features
-          @dataset.metadata = load_metadata
+          load_features subjectid
+          @dataset.metadata = load_metadata(subjectid)
           @dataset
         end
 
         # Read only features from a dataset service. 
         # @return [Hash] Internal features representation
-        def load_features
-          uri = File.join(@uri,"features")
+        def load_features(subjectid=nil)
+          if File.exist?(@uri)
+            file = File.new(@uri)
+          else
+            file = Tempfile.new("ot-rdfxml")
+            # do not concat /features to uri string, this would not work for dataset/R401577?max=3 
+            uri = URI::parse(@uri)
+            uri.path = File.join(uri.path,"features")
+            uri = uri.to_s
+            file.puts OpenTox::RestClientWrapper.get uri,{:subjectid => subjectid,:accept => "application/rdf+xml"},nil,false
+            file.close
+            to_delete = file.path
+          end
           statements = []
           features = Set.new
-          `rapper -i rdfxml -o ntriples #{uri} 2>/dev/null`.each_line do |line|
+          `rapper -i rdfxml -o ntriples #{file.path} 2>/dev/null`.each_line do |line|
             triple = line.chomp.split('> ').collect{|i| i.sub(/\s+.$/,'').gsub(/[<>"]/,'')}[0..2]
             statements << triple
-            features << triple[0] if triple[1] == RDF['type'] and triple[2] == OT.Feature
+            features << triple[0] if triple[1] == RDF['type'] and (triple[2] == OT.Feature || triple[2] == OT.NumericFeature) 
           end
+          File.delete(to_delete) if to_delete
           statements.each do |triple|
             if features.include? triple[0]
               @dataset.features[triple[0]] = {} unless @dataset.features[triple[0]] 

data/lib/policy.rb

@@ -0,0 +1,261 @@
+module OpenTox
+  require "rexml/document"
+
+  #Module for policy-processing 
+  # @see also http://www.opentox.org/dev/apis/api-1.2/AA for opentox API specs
+  # Class Policies corresponds to <policies> container of an xml-policy-fle
+  class Policies 
+  
+    attr_accessor :name, :policies
+    
+    def initialize()
+      @policies = {}
+    end
+    
+    #create new policy instance with name
+    # @param [String]name of the policy
+    def new_policy(name)
+      @policies[name] = Policy.new(name)
+    end
+    
+    #drop a specific policy in a policies instance
+    # @param [String]name of the policy
+    # @return [Boolean]
+    def drop_policy(name)
+      return true if @policies.delete(name) 
+    end
+
+    #drop all policies in a policies instance
+    def drop_policies
+      @policies.each do |name, policy|
+        drop_policy(name)
+      end
+      return true
+    end
+    
+    # @return [Array] set of arrays affected by policies
+    def uris
+      @policies.collect{ |k,v| v.uris }.flatten.uniq
+    end
+
+        #drop all policies in a policies instance
+    def names
+      out = []
+      @policies.each do |name, policy|
+        out << name 
+      end
+      return out
+    end
+
+    #loads a default policy template in policies instance
+    def load_default_policy(user, uri, group="member")    
+      template = case user
+        when "guest", "anonymous" then "default_guest_policy"
+        else "default_policy"     
+      end
+      xml = File.read(File.join(File.dirname(__FILE__), "templates/#{template}.xml"))
+      self.load_xml(xml)
+      datestring = Time.now.strftime("%Y-%m-%d-%H-%M-%S-x") + rand(1000).to_s
+       
+      @policies["policy_user"].name = "policy_user_#{user}_#{datestring}"
+      @policies["policy_user"].rules["rule_user"].uri = uri
+      @policies["policy_user"].rules["rule_user"].name = "rule_user_#{user}_#{datestring}"
+      @policies["policy_user"].subjects["subject_user"].name = "subject_user_#{user}_#{datestring}"
+      @policies["policy_user"].subjects["subject_user"].value = "uid=#{user},ou=people,dc=opentox,dc=org"
+      @policies["policy_user"].subject_group = "subjects_user_#{user}_#{datestring}"
+            
+      @policies["policy_group"].name = "policy_group_#{group}_#{datestring}" 
+      @policies["policy_group"].rules["rule_group"].uri = uri
+      @policies["policy_group"].rules["rule_group"].name = "rule_group_#{group}_#{datestring}"
+      @policies["policy_group"].subjects["subject_group"].name = "subject_group_#{group}_#{datestring}"
+      @policies["policy_group"].subjects["subject_group"].value = "cn=#{group},ou=groups,dc=opentox,dc=org"
+      @policies["policy_group"].subject_group = "subjects_#{group}_#{datestring}" 
+      return true
+    end    
+
+    #loads a xml template    
+    def load_xml(xml)
+      rexml = REXML::Document.new(xml)
+      rexml.elements.each("Policies/Policy") do |pol|    #Policies
+        policy_name = pol.attributes["name"]
+        new_policy(policy_name)
+        #@policies[policy_name] = Policy.new(policy_name)      
+        rexml.elements.each("Policies/Policy[@name='#{policy_name}']/Rule") do |r|    #Rules
+          rule_name = r.attributes["name"]        
+          uri = rexml.elements["Policies/Policy[@name='#{policy_name}']/Rule[@name='#{rule_name}']/ResourceName"].attributes["name"]
+          @policies[policy_name].rules[rule_name] = @policies[policy_name].new_rule(rule_name, uri)
+          rexml.elements.each("Policies/Policy[@name='#{policy_name}']/Rule[@name='#{rule_name}']/AttributeValuePair") do |attribute_pairs|
+            action=nil; value=nil;
+            attribute_pairs.each_element do |elem|
+              action = elem.attributes["name"] if elem.attributes["name"]
+              value = elem.text if elem.text
+            end
+            if action and value
+              case action
+              when "GET"
+                @policies[policy_name].rules[rule_name].get    = value
+              when "POST"
+                @policies[policy_name].rules[rule_name].post   = value
+              when "PUT"
+                @policies[policy_name].rules[rule_name].put    = value
+              when "DELETE"    
+                @policies[policy_name].rules[rule_name].delete = value
+              end
+            end
+          end        
+        end
+        rexml.elements.each("Policies/Policy[@name='#{policy_name}']/Subjects") do |subjects|    #Subjects
+          @policies[policy_name].subject_group = subjects.attributes["name"]        
+          rexml.elements.each("Policies/Policy[@name='#{policy_name}']/Subjects[@name='#{@policies[policy_name].subject_group}']/Subject") do |s|    #Subject
+            subject_name  = s.attributes["name"]
+            subject_type  = s.attributes["type"]
+            subject_value = rexml.elements["Policies/Policy[@name='#{policy_name}']/Subjects[@name='#{@policies[policy_name].subject_group}']/Subject[@name='#{subject_name}']/AttributeValuePair/Value"].text
+            @policies[policy_name].new_subject(subject_name, subject_type, subject_value) if subject_name and subject_type and subject_value
+          end
+        end      
+      end    
+    end
+    
+    #generates xml from policies instance
+    def to_xml
+      doc = REXML::Document.new()
+      doc <<  REXML::DocType.new("Policies", "PUBLIC  \"-//Sun Java System Access Manager7.1 2006Q3\n Admin CLI DTD//EN\" \"jar://com/sun/identity/policy/policyAdmin.dtd\"")
+      doc.add_element(REXML::Element.new("Policies"))
+      
+      @policies.each do |name, pol|
+        policy = REXML::Element.new("Policy")
+        policy.attributes["name"] = pol.name
+        policy.attributes["referralPolicy"] = false
+        policy.attributes["active"] = true
+        @policies[name].rules.each do |r,rl|
+          rule = @policies[name].rules[r]
+          out_rule = REXML::Element.new("Rule")
+          out_rule.attributes["name"] = rule.name
+          servicename = REXML::Element.new("ServiceName")
+          servicename.attributes["name"]="iPlanetAMWebAgentService"
+          out_rule.add_element(servicename)
+          rescourcename = REXML::Element.new("ResourceName")
+          rescourcename.attributes["name"] = rule.uri
+          out_rule.add_element(rescourcename)
+          
+          ["get","post","delete","put"].each do |act|
+            if rule.method(act).call
+              attribute = REXML::Element.new("Attribute") 
+              attribute.attributes["name"] = act.upcase
+              attributevaluepair = REXML::Element.new("AttributeValuePair")
+              attributevaluepair.add_element(attribute)
+              attributevalue = REXML::Element.new("Value")
+              attributevaluepair.add_element(attributevalue)
+              attributevalue.add_text REXML::Text.new(rule.method(act).call)
+              out_rule.add_element(attributevaluepair)
+              
+            end
+          end
+          policy.add_element(out_rule)
+        end      
+
+        subjects = REXML::Element.new("Subjects")
+        subjects.attributes["name"] = pol.subject_group
+        subjects.attributes["description"] = ""
+        @policies[name].subjects.each do |subj, subjs|
+          subject = REXML::Element.new("Subject")
+          subject.attributes["name"] = pol.subjects[subj].name
+          subject.attributes["type"] = pol.subjects[subj].type
+          subject.attributes["includeType"] = "inclusive"
+          attributevaluepair = REXML::Element.new("AttributeValuePair")
+          attribute = REXML::Element.new("Attribute") 
+          attribute.attributes["name"] = "Values"
+          attributevaluepair.add_element(attribute)
+          attributevalue = REXML::Element.new("Value")
+          attributevalue.add_text REXML::Text.new(pol.subjects[subj].value)
+          attributevaluepair.add_element(attributevalue)
+          subject.add_element(attributevaluepair)
+          subjects.add_element(subject)
+        end
+        policy.add_element(subjects)
+        doc.root.add_element(policy)
+      end    
+      out = ""
+      doc.write(out, 2)
+      return out
+    end  
+    
+  end
+  
+  #single policy in a policies instance
+  class Policy 
+  
+    attr_accessor :name, :rules, :subject_group, :subjects
+  
+    def initialize(name)
+      @name = name
+      @rules = {}
+      @subject_group = ""
+      @subjects = {}
+    end
+    
+    #create a new rule instance for the policy
+    def new_rule(name, uri)
+      @rules[name] = Rule.new(name, uri)
+    end
+    
+    #create a new subject instance for the policy 
+    def new_subject(name, type, value)
+      @subjects[name] = Subject.new(name, type, value)
+    end
+    
+    # @return [Array] set of uris affected by policy
+    def uris
+      @rules.collect{ |k,v| v.uri }.uniq
+    end
+    
+    #rule inside a policy
+    class Rule
+      
+      attr_accessor :name, :uri, :get, :post, :put, :delete
+      
+      def initialize(name, uri)
+        @name = name
+        @uri = uri
+      end
+      
+      def rename(new, old)
+        self[new] = self.delete(old)
+        self[new].name = new
+      end
+      
+      def get=(value)
+        @get = check_value(value, @get)
+      end
+    
+      def post=(value)
+        @post = check_value(value, @post)
+      end
+          
+      def delete=(value)
+        @delete = check_value(value, @delete)
+      end
+      
+      def put=(value)
+        @put = check_value(value, @put)
+      end
+          
+      private
+      #checks if value is allow or deny. returns old value if not valid. 
+      def check_value(new_value, old_value)
+        return (new_value=="allow" || new_value=="deny" || new_value==nil) ? new_value : old_value 
+      end
+    end
+    
+    class Subject
+
+      attr_accessor :name, :type, :value  
+
+      def initialize(name, type, value)
+        @name  = name
+        @type  = type
+        @value = value
+      end
+    end
+  end
+end