sos-core 0.1.3

data/lib/employees/mankind/people.rb

@@ -0,0 +1,58 @@
+class People
+	def initialize(tasks=nil)
+		@tasks = tasks.to_a
+		@attributes = ""
+	end
+
+	def do(tasks)
+
+	end
+
+	def typeOf(task, args={})
+		raise ArgumentError "Set check type" if args == {}
+		type = args[:is] || args[:is_not]
+		return task.class == type if not args[:is].nil?
+		return task.class != type if not args[:is_not].nil?
+	end
+
+	def inspect
+		tag
+	end
+
+	def inject(task)
+		task if typeOf task, is: String
+	end
+
+	def tag(value=nil)
+		"<#{namespace}#{tag_name}>#{value.to_s}</#{namespace}#{tag_name}> "
+	end
+
+	def tag_name
+		uncapitalize self.class.to_s
+	end
+
+	def uncapitalize(name)
+		name = name.dup
+		name[0] = name[0].downcase;
+		name
+	end
+
+	def capitalize(name)
+		name = name.dup
+		name[0] = name[0].upcase;
+		name
+	end
+
+	def attributes(attrs)
+		attrs.each { |k, v| @attributes += " #{namespace}" + k.to_s + "=\"" + v.to_a[0] + "\"" }
+	end
+
+	def class_name
+		self.class.to_s
+	end
+
+	def namespace
+		nil
+	end
+
+end

data/lib/employees/mankind/simple.rb

@@ -0,0 +1,16 @@
+require_relative 'people.rb'
+
+class Simple < People
+	def do(tasks)
+		raise ArgumentError, "It must be Array in the hash" unless tasks.is_a? Array
+
+		tasks = tasks.to_a.map do |task|
+					tag inject task
+				end
+		tasks.join " "
+	end
+
+	def namespace
+		"sos:"
+	end
+end

data/lib/employees/sos.rb

@@ -0,0 +1,2 @@
+require_relative 'man.rb'
+Dir[ File.dirname(__FILE__) + "/sos/*.rb"].each {|file| require file }

data/lib/employees/sos/offering.rb

@@ -0,0 +1,22 @@
+class Offering < Simple
+	
+end
+
+class Procedure < Simple
+	
+end
+
+class ObservedProperty < Simple
+	
+end
+
+class FeatureOfInterest < Simple
+	
+end
+
+class ResponseFormat < Simple
+	
+end
+
+# a = Procedure.new()
+# p a.do ["1", "2", "3", "4", "5"]

data/lib/employees/sos/temporalFilter.rb

@@ -0,0 +1,5 @@
+class TemporalFilter < Complicated
+	def namespace
+		"sos:"
+	end
+end

data/lib/sos-core.rb

@@ -0,0 +1,35 @@
+require_relative 'sos-helper.rb'
+
+class SOS
+
+	def initialize(url, args={})
+		# request to http://cgis.csrsr.ncu.edu.tw:8080/swcb-sos-new/service
+		@request = XmlRequest.new(url)
+		@capabilities = getCapabilities
+		@observations, @gc, @go = nil
+	end
+
+	def allowedValue
+		@allowedValue ||= checkAllowedValues
+	end
+	
+	def getCapabilities(query={})
+		@gc = SOSHelper::GetCapability.new(request: @request)
+		@capabilities = @gc.send
+	end
+
+	def checkAllowedValues
+		@gc.checkAllowedValues
+	end
+
+	def getObservations(condition={})
+		@go = SOSHelper::GetObservation.new(request: @request)
+		filter condition unless condition == {}
+		@go
+	end
+	
+	def offering
+		@offerings = @offerings || @capabilities.xpath("//sos:Contents//swes:offering").map { |node| Offering.new(node) } unless @capabilities.nil?
+	end
+	
+end

data/lib/sos-helper.rb

@@ -0,0 +1,21 @@
+require 'set'
+require 'nokogiri'
+Dir[ File.dirname(__FILE__) + "/employees/*.rb"].each {|file| require file }
+require_relative 'board_of_directors/factory/factory.rb'
+require_relative 'board_of_directors/boss.rb'
+Dir[ File.dirname(__FILE__) + "/sos_helper/*.rb"].each {|file| require file }
+
+module SOSHelper
+	Dir[ File.dirname(__FILE__) + "/sos_helper/*.rb"]
+	Urls = ["http://cgis.csrsr.ncu.edu.tw:8080/swcb-sos-new/service",
+			  "http://cgis.csrsr.ncu.edu.tw:8080/epa-sos/service",
+			  "http://cgis.csrsr.ncu.edu.tw:8080/epa-aqx-sos/service"].freeze
+
+	Relics = ["offering","observedProperty",
+	     "featureOfInterest",
+		 "procedure", "spatialFilter", 
+		 "temporalFilter", "responseFormat"].freeze
+
+	ObservationRequest = File.open(File.dirname(__FILE__) + '/sos_helper/getObservation.xml') { |f| Nokogiri::XML(f)  }.freeze
+
+end

data/lib/sos_helper/capability.rb

@@ -0,0 +1,65 @@
+module SOSHelper
+	class GetCapability
+
+		def initialize(args={})
+			@request = args[:request]
+			@url = args[:url]
+			@query = {}
+			@allowedValue = {}
+			@capabilities = nil
+		end
+
+		def send(query={})
+			query[:service] = query[:service] || "SOS"
+			query[:request] = query[:request] || "GetCapabilities"
+			@capabilities = request.get(query) { |str| next Nokogiri::XML(str) }
+		end
+
+		def checkAllowedValues(capabilities=nil)
+
+			@allowedValue = check Relics
+		end
+
+		private
+
+		def dig(operation, type="Value")
+			@capabilities.xpath("//ows:Operation[@name='GetObservation']//ows:Parameter[@name='#{operation}']//ows:#{type}")
+		end
+
+		def request
+			@request ||= XmlRequest.new(@url)
+		end
+
+		def check(relics)
+			backpack = {}
+
+			relics.each do |relic|
+				level = checkLevelOf relic
+
+				backpack[ relic.to_sym ] = adventure level, relic
+			end
+
+			backpack
+		end
+
+		def adventure(level, relic)
+			if level == "normal"
+				(dig relic).map { |treasure| normal treasure }
+			else
+				(dig relic, "Range").map { |treasure| complex treasure}
+			end
+		end
+
+		def checkLevelOf(condition)
+			!(condition.include? "Filter") ? "normal" : "complex"
+		end
+
+		def normal(tag)
+			tag.text
+		end
+
+		def complex(tag)
+			[tag.xpath(".//ows:MinimumValue").text, tag.xpath(".//ows:MaximumValue").text]
+		end
+	end
+end

data/lib/sos_helper/getObservation.xml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<sos:GetObservation
+    xmlns:sos="http://www.opengis.net/sos/2.0"
+    xmlns:fes="http://www.opengis.net/fes/2.0"
+    xmlns:gml="http://www.opengis.net/gml/3.2"
+    xmlns:swe="http://www.opengis.net/swe/2.0"
+    xmlns:xlink="http://www.w3.org/1999/xlink"
+    xmlns:swes="http://www.opengis.net/swes/2.0"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" service="SOS" version="2.0.0" xsi:schemaLocation="http://www.opengis.net/sos/2.0 http://schemas.opengis.net/sos/2.0/sos.xsd">
+    
+</sos:GetObservation>

data/lib/sos_helper/node.rb

@@ -0,0 +1,30 @@
+class Node
+	NAMESPACE = { id: "swes:identifier", 
+				  procedure: "swes:procedure", 
+				  observableProperty: "swes:observableProperty",
+				  observedArea: "sos:observedArea",
+				  envelope: "gml:Envelope",
+				  lowerCorner: "gml:lowerCorner",
+				  upperCorner: "gml:upperCorner",
+				  timePeriod: "gml:TimePeriod",
+				  phenomenonTime: "sos:phenomenonTime",
+				  begin: "gml:beginPosition",
+				  end: "gml:endPosition",
+				  resultTime: "sos:resultTime"}
+
+	def initialize(node)
+		@node = node.dup
+	end
+
+	def [](name)
+		Node.new @node.xpath(".//#{NAMESPACE[name]}")
+	end
+
+	def method_missing(name)
+		@node.send(name)
+	end
+
+	def inspect
+		self.to_s
+	end
+end

data/lib/sos_helper/observation.rb

@@ -0,0 +1,77 @@
+module SOSHelper
+
+	class Observation
+		def initialize(args)
+			
+		end
+	end
+
+	# GetObservation just focus on two things:
+	# 		filter conditions into hash
+	# 		send the conditions to specific @request
+	class GetObservation
+
+		def initialize(args={})
+			@request = args[:request]
+			@xml = ObservationRequest.dup
+			@request_body = nil
+			@body = ""
+		end
+
+		# Without preset Conditions is Okay
+		def send(body=nil, &block)
+			raise RuntimeError, 'Need to set request' if @request.nil?
+			@body = condition.transform @xml if body.nil?
+			@request.post(@body, &block) if block_given?
+		end
+
+		def body(body=nil)
+			@body = body
+		end
+
+		# filter() =>  no argument to return @condtion
+		# filter({:condition => "value"}) =>  extend @condition
+		def filter(custom={})
+			raise ArgumentError, 'Filters need to be hash' unless custom.is_a? Hash
+			return condition.to_s if custom == {}
+			condition.merge! custom
+
+			self
+		end
+
+		def inspect
+			"<GetObservation 0x#{self.__id__} @condition= #{condition}>"
+		end
+
+		def condition
+			@condition ||= Factory.new()
+		end
+
+		def offering(text)
+			filter({offering: text})
+		end
+
+		def procedure(text)
+			filter({procedure: text})
+		end
+
+		def observedProperty(text)
+			filter({observedProperty: text})
+		end
+
+		def temporalFilter(id, range)
+			filter({ temporalFilter: {
+						during: {
+				 			valueReference: "phenomenonTime",
+				 			timePeriod: { attributes: { id: id }, range: range } }
+					  	}
+		  			})
+		end
+
+		def responseFormat(text)
+			filter({responseFormat: text})
+		end
+
+	end
+
+end

data/lib/sos_helper/offering.rb

@@ -0,0 +1,49 @@
+require_relative 'node'
+
+module SOSHelper
+	class Offering
+		ATRRIBUTES = [ :identifier, :procedure, :observableProperty, :observedArea, :resultTime, :phenomenonTime, :node ]
+		ATRRIBUTES.each { |t| attr_reader t }
+
+		def initialize(xml_offer)
+			@node = Node.new xml_offer
+			@id, @procedure = getText(:id), getText(:procedure)
+			@observableProperty = getList(:observableProperty)
+			@observedArea = getHash(:observedArea, [:lowerCorner, :upperCorner])
+			@phenomenonTime = getHash(:phenomenonTime, [:begin, :end])
+			@resultTime = getHash(:resultTime, [:begin, :end])
+
+		end
+
+		def getText(name)
+			@node[name].text
+		end
+
+		def getList(name)
+			@node[name].children.map { |node| node.text }
+		end
+
+		def getHash(name, scope=[])
+			hash = {}
+			scope.each { |s| hash.store(s, @node[name][s].text )} unless scope.empty?
+			hash
+		end
+
+		def to_json
+			{ "identifier": @id, 
+			  "procedure": @procedure,
+			  "observableProperty": @observableProperty,
+			  "observedArea": @observedArea,
+			  "phenomenonTime": @phenomenonTime,
+			  "resultTime": @resultTime }
+		end
+
+		def to_s
+			to_json.to_s
+		end
+
+	end
+
+end
+# p a.node.inspect
+# p a.to_json

data/lib/sos_helper/xmlRequest.rb

@@ -0,0 +1,54 @@
+require "uri"
+require "net/http"
+require "json"
+
+# To send get or post request with custom payload.
+# 
+# Usage:
+# => hello = XmlRequest.new( uri )
+# => hello.get({service: "SOS", request: "GetCapabilities"})
+#
+class XmlRequest
+
+	attr_accessor :uri, :packet, :post
+
+	def initialize(url)
+		@uri = url
+		@packet = Net::HTTP.new(uri.host, uri.port)
+		@query = nil
+	end
+
+	def post(body=nil, &block)
+		@post = Net::HTTP::Post.new(uri.path)
+		@post["Content-type"] = "application/xml"
+		@post.body = body
+		# File.new("./request/request-tmp", "w").write body.dup
+		p body, "packet sending, it may take times to get response..."
+		@res = send @post
+		@result = yield @res.body if block_given?
+	end
+
+	def get(query={}, &block)
+		fullPath = path_combine query
+		@get = Net::HTTP::Get.new(fullPath)
+		@res = send @get
+		@result = yield @res.body if block_given?
+	end
+
+	private
+
+	def uri
+		URI(@uri)
+	end
+
+	def path_combine(query={})
+		params = URI.encode_www_form(query)
+		[uri.path, params].join('?')
+	end
+
+	def send(action)
+		@packet.request( action )
+	end
+
+end
+