1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
|
# defaults to stderr, may be changed to file output (e.g in opentox-service)
$logger = OTLogger.new(STDERR)
$logger.level = Logger::DEBUG
module OpenTox
#include RDF CH: leads to namespace clashes with URI class
attr_reader :uri, :subjectid
attr_writer :metadata, :parameters
# Ruby interface
# Create a new OpenTox object
# @param uri [optional,String] URI
# @param subjectid [optional,String]
# @return [OpenTox] OpenTox object
def initialize uri=nil, subjectid=nil
@rdf = RDF::Graph.new
@subjectid = subjectid
@metadata = {}
@parameters = []
uri ? @uri = uri.to_s.chomp : @uri = File.join(service_uri, SecureRandom.uuid)
end
# Object metadata (lazy loading)
# @return [Hash] Object metadata
def metadata force_update=false
if (@metadata.nil? or @metadata.empty? or force_update) and URI.accessible? @uri, @subjectid
get if @rdf.nil? or @rdf.empty? or force_update
# return values as plain strings instead of RDF objects
@metadata = @rdf.to_hash[RDF::URI.new(@uri)].inject({}) { |h, (predicate, values)| h[predicate] = values.collect{|v| v.to_s}; h }
end
@metadata
end
# Metadata values
# @param predicate [String] Predicate URI
# @return [Array, String] Predicate value(s)
def [](predicate)
return nil if metadata[predicate].nil?
metadata[predicate].size == 1 ? metadata[predicate].first : metadata[predicate]
end
# Set a metadata entry
# @param predicate [String] Predicate URI
# @param values [Array, String] Predicate value(s)
def []=(predicate,values)
@metadata[predicate] = [values].flatten
end
# Object parameters (lazy loading)
# {http://opentox.org/dev/apis/api-1.2/interfaces OpenTox API}
# @return [Hash] Object parameters
def parameters force_update=false
if (@parameters.empty? or force_update) and URI.accessible? @uri, @subjectid
get if @rdf.empty? or force_update
params = {}
query = RDF::Query.new({
:parameter => {
RDF.type => RDF::OT.Parameter,
:property => :value,
}
})
query.execute(@rdf).each do |solution|
params[solution.parameter] = {} unless params[solution.parameter]
params[solution.parameter][solution.property] = solution.value
end
@parameters = params.values
end
@parameters
end
# Parameter value
# @param [String] title
# @return [String] value
def parameter_value title
@parameters.collect{|p| p[RDF::OT.paramValue] if p[RDF::DC.title] == title}.compact.first
end
# Get object from webservice
# @param [String,optional] mime_type
def get mime_type="text/plain"
bad_request_error "Mime type #{mime_type} is not supported. Please use 'text/plain' (default) or 'application/rdf+xml'." unless mime_type == "text/plain" or mime_type == "application/rdf+xml"
response = RestClientWrapper.get(@uri,{},{:accept => mime_type, :subjectid => @subjectid})
if URI.task?(response)
uri = wait_for_task response
response = RestClientWrapper.get(uri,{},{:accept => mime_type, :subjectid => @subjectid})
end
parse_ntriples response if mime_type == "text/plain"
parse_rdfxml response if mime_type == "application/rdf+xml"
end
# Post object to webservice (append to object), rarely useful and deprecated
# @deprecated
def post wait=true, mime_type="text/plain"
bad_request_error "Mime type #{mime_type} is not supported. Please use 'text/plain' (default) or 'application/rdf+xml'." unless mime_type == "text/plain" or mime_type == "application/rdf+xml"
case mime_type
when 'text/plain'
body = self.to_ntriples
when 'application/rdf+xml'
body = self.to_rdfxml
end
Authorization.check_policy(@uri, @subjectid) if $aa[:uri]
uri = RestClientWrapper.post @uri.to_s, body, { :content_type => mime_type, :subjectid => @subjectid}
wait ? wait_for_task(uri) : uri
end
# Save object at webservice (replace or create object)
def put wait=true, mime_type="text/plain"
bad_request_error "Mime type #{mime_type} is not supported. Please use 'text/plain' (default) or 'application/rdf+xml'." unless mime_type == "text/plain" or mime_type == "application/rdf+xml"
case mime_type
when 'text/plain'
body = self.to_ntriples
when 'application/rdf+xml'
body = self.to_rdfxml
end
uri = RestClientWrapper.put @uri.to_s, body, { :content_type => mime_type, :subjectid => @subjectid}
wait ? wait_for_task(uri) : uri
end
# Delete object at webservice
def delete
RestClientWrapper.delete(@uri.to_s,nil,{:subjectid => @subjectid})
Authorization.delete_policies_from_uri(@uri, @subjectid) if $aa[:uri]
end
def service_uri
self.class.service_uri
end
def create_rdf
@rdf = RDF::Graph.new if @rdf.empty? or URI.task?(@uri)
@metadata[RDF.type] ||= eval("RDF::OT."+self.class.to_s.split('::').last)
@metadata[RDF::DC.date] ||= DateTime.now
@metadata.each do |predicate,values|
[values].flatten.each do |value|
predicate =~ /#{RDF::DC.date}|#{RDF::DC.title}|#{RDF::DC.description}/ ? @rdf.update([RDF::URI.new(@uri), predicate, value]) : @rdf << [RDF::URI.new(@uri), predicate, value]
end
end
@parameters.each do |parameter|
p_node = RDF::Node.new
@rdf << [RDF::URI.new(@uri), RDF::OT.parameters, p_node]
@rdf << [p_node, RDF.type, RDF::OT.Parameter]
parameter.each { |k,v| @rdf << [p_node, k, v] }
end
end
# as defined in opentox-client.rb
RDF_FORMATS.each do |format|
# rdf parse methods for all formats e.g. parse_rdfxml
send :define_method, "parse_#{format}".to_sym do |rdf|
@rdf = RDF::Graph.new
RDF::Reader.for(format).new(rdf) do |reader|
reader.each_statement{ |statement| @rdf << statement }
end
end
# rdf serialization methods for all formats e.g. to_rdfxml
send :define_method, "to_#{format}".to_sym do
create_rdf
RDF::Writer.for(format).buffer(:encoding => Encoding::ASCII) do |writer|
writer << @rdf
end
end
end
# @return [String] converts object to turtle-string
def to_turtle # redefined to use prefixes (not supported by RDF::Writer)
prefixes = {:rdf => "http://www.w3.org/1999/02/22-rdf-syntax-ns#"}
['OT', 'DC', 'XSD', 'OLO'].each{|p| prefixes[p.downcase.to_sym] = eval("RDF::#{p}.to_s") }
create_rdf
RDF::Writer.for(:turtle).buffer(:prefixes => prefixes) do |writer|
writer << @rdf
end
end
# @return [String] converts OpenTox object into html document (by first converting it to a string)
def to_html
to_turtle.to_html
end
# short access for metadata keys title, description and type
{ :title => RDF::DC.title, :description => RDF::DC.description, :type => RDF.type }.each do |method,predicate|
send :define_method, method do
self.[](predicate)
end
send :define_method, "#{method}=" do |value|
self.[]=(predicate,value)
end
end
# create default OpenTox classes with class methods
# (defined in opentox-client.rb)
CLASSES.each do |klass|
c = Class.new do
include OpenTox
def self.all subjectid=nil
uris = RestClientWrapper.get(service_uri, {}, :accept => 'text/uri-list', :subjectid => subjectid).split("\n").compact
uris.collect{|uri| self.new(uri, subjectid)}
end
#@example fetching a model
# OpenTox::Model.find(<model-uri>) -> model-object
def self.find uri, subjectid=nil
URI.accessible?(uri, subjectid) ? self.new(uri, subjectid) : nil
end
def self.create metadata, subjectid=nil
object = self.new nil, subjectid
object.metadata = metadata
object.put
object
end
def self.find_or_create metadata, subjectid=nil
sparql = "SELECT DISTINCT ?s WHERE { "
metadata.each do |predicate,objects|
unless [RDF::DC.date,RDF::DC.modified,RDF::DC.description].include? predicate # remove dates and description (strange characters in description may lead to SPARQL errors)
if objects.is_a? String
URI.valid?(objects) ? o = "<#{objects}>" : o = "'''#{objects}'''"
sparql << "?s <#{predicate}> #{o}. "
elsif objects.is_a? Array
objects.each do |object|
URI.valid?(object) ? o = "<#{object}>" : o = "'#{object}'"
sparql << "?s <#{predicate}> #{o}. "
end
end
end
end
sparql << "}"
uris = RestClientWrapper.get(service_uri,{:query => sparql},{:accept => "text/uri-list", :subjectid => subjectid}).split("\n")
if uris.empty?
self.create metadata, subjectid
else
self.new uris.first, subjectid
end
end
def self.service_uri
service = self.to_s.split('::').last.downcase
eval("$#{service}[:uri]")
rescue
bad_request_error "$#{service}[:uri] variable not set. Please set $#{service}[:uri] or use an explicit uri as first constructor argument "
end
end
OpenTox.const_set klass,c
end
end
|