#!/usr/bin/ruby

# Apache License, Version 2.0

#

# Copyright (c) 2013 Juergen Mangler

#

# Licensed under the Apache License, Version 2.0 (the "License");

# you may not use this file except in compliance with the License.

# You may obtain a copy of the License at

#

#     http://www.apache.org/licenses/LICENSE-2.0

#

# Unless required by applicable law or agreed to in writing, software

# distributed under the License is distributed on an "AS IS" BASIS,

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

# See the License for the specific language governing permissions and

# limitations under the License.

 

require 'rubygems'

require 'riddl/server'

require 'json'

require 'xml/smart'

require 'fileutils'

require 'term/ansicolor'

class String

  include Term::ANSIColor

end

 

class Worker #{{{

  def initialize(*para)

    @para = para

  end

  def process(doc,mdoc,sdoc,f) #{{{

    if doc.find("string(/g:gatewayRequest/g:header/g:operationName)") == mdoc.find("string(/g:gatewayResponse/g:header/g:operationName)")

      ips = doc.find("/g:gatewayRequest/g:payload/g:inputParameter")

      count = 0

      ips.each do |e|

        i = sdoc.find("/r:summary/r:info/r:info[@name=\"#{e.attributes['paramName']}\"]")

        count += 1 if i.any? && i.first.attributes['value'] == e.text

      end

      count == ips.length ? File.basename(File.dirname(f)) : nil

    end

  end

  private :process #}}}

  def process_rule #{{{

    doc = @para[0]

    ret = []

    Dir.glob(File.dirname(__FILE__) + "/messages/*/xml").sort{|a,b| a.split('/')[2].to_i <=> b.split('/')[2].to_i}.each do |f|

      XML::Smart.open_unprotected(f) do |mdoc|

        sdoc = nil

        mdoc.register_namespace 'g', 'http://www.fp7-adventure.eu/xmlSchema/Gateways/'

        mdoc.find("/g:gatewayResponse/g:payload/g:outputData[@paramName='summary']").each do |e|

          if e.text_only?

            sdoc = XML::Smart::string(e.text)

            sdoc.root.namespaces.add(nil,'http://www.fp7-adventure.eu/xmlSchema/Gateways/')

          else

            sdoc = e.children.first.to_doc

          end  

          sdoc.register_namespace 'r', 'http://www.fp7-adventure.eu/xmlSchema/Gateways/'

        end  

        ret << process(doc,mdoc,sdoc,f)

      end

    end

    ret.compact

  end #}}}

  def process_message #{{{

    mdoc = @para[0]

    sdoc = nil

    mdoc.find("/g:gatewayResponse/g:payload/g:outputData[@paramName='summary']").each do |e|

      if e.text_only?

        sdoc = XML::Smart::string(e.text)

        sdoc.root.namespaces.add(nil,'http://www.fp7-adventure.eu/xmlSchema/Gateways/')

      else

        sdoc = e.children.first.to_doc

      end  

      sdoc.register_namespace 'r', 'http://www.fp7-adventure.eu/xmlSchema/Gateways/'

    end  

    ret = []

    Dir.glob(File.dirname(__FILE__) + "/rules/*/xml").each do |f|

      XML::Smart.open_unprotected(f) do |doc|

        doc.register_namespace 'g', 'http://www.fp7-adventure.eu/xmlSchema/Gateways/'

        ret << process(doc,mdoc,sdoc,f)

      end

    end

    ret.compact

  end #}}}

  def list #{{{

    list = []

    %w{rules messages}.each do |e|

      Dir[File.dirname(__FILE__) + "/#{e}/*"].each do |f|

        meta = {}

        meta['id'] = File.basename(f)

        meta['type'] = e.chop

        meta.merge!(JSON.parse(File.read(f + '/meta'))) if File.exists?(f + '/meta')

        list << meta

      end if @para.empty? || @para[0] == e

    end  

    list.sort{|a,b| [a['type'],a['id'].to_i] <=> [b['type'],b['id'].to_i]}

  end  #}}}

  def details #{{{

    return [] if @para.length < 2 && (@para[0] != 'rule' || @para[0] != 'message')

    path = @para[0] == 'rule' ? 'rules' : 'messages'

    name = File.dirname(__FILE__) + "/#{path}/#{@para[1].to_i}/xml"

    File.exists?(name) ? File.read(name) : nil

  end #}}}

  def delete #{{{

    if @para.length > 1 && (@para[0] == 'rule' || @para[0] == 'message')

      path = @para.shift == 'rule' ? 'rules' : 'messages'

      mess = nil

      @para.each do |par|

        name = File.dirname(__FILE__) + "/#{path}/#{par.to_i}"

        if File.exists?(name)

          FileUtils.rm_r(name)

        else

          mess = "some don't exist"

        end

      end

      mess

    else

      "won't do"

    end

  end #}}}

end #}}}

 

class RuleProcess < Riddl::Implementation #{{{

  def response

    rdoc = XML::Smart::string(@p[0].value.read)

    rdoc.register_namespace 'g', 'http://www.fp7-adventure.eu/xmlSchema/Gateways/'

    meta = {

      'op' => rdoc.find('string(//g:header/g:operationName)'),

      'time' => Time.now.to_s,

      'source' => @h['CPEE_CALLBACK']

    }

 

    save = true

    messages = Worker.new(rdoc).process_rule

    if messages.length > 0

      what = JSON.parse(File.read(File.dirname(__FILE__) + "/messages/#{messages[0]}/meta"))

      mdoc = XML::Smart.open_unprotected(File.dirname(__FILE__) + "/messages/#{messages[0]}/xml")

      mdoc.register_namespace 'g', 'http://www.fp7-adventure.eu/xmlSchema/Gateways/'

      client = Riddl::Client.interface("xmpp://" + meta['source'], "callback.xml", :xmpp => @env['xmpp'])

      client.put Riddl::Parameter::Complex.new("gatewayResponse","text/xml",mdoc.to_s)

      save = false if mdoc.find('string(//g:header/g:commandSequence)') == 'LAST'

      Worker.new('message',messages[0]).delete if what['validity'] == 'FOREVER'

    end

 

    if save

      begin

        id = id.nil? ? 0 : id + 1

        Dir.mkdir(File.dirname(__FILE__) + "/rules/#{id}")

      rescue SystemCallError

        retry

      end

      

      File.write(File.dirname(__FILE__) + "/rules/#{id}/meta", JSON.pretty_generate(meta))

      File.write(File.dirname(__FILE__) + "/rules/#{id}/xml", rdoc.to_s)

    end

    nil

  end

end #}}}

class MessageProcess < Riddl::Implementation #{{{

  def response

    mdoc = XML::Smart::string(@p[0].value.read)

    mdoc.register_namespace 'g', 'http://www.fp7-adventure.eu/xmlSchema/Gateways/'

    meta = {

      'source' => @env['from'] ? @env['from'].split('/',2)[0] : 'some http',

      'op' => mdoc.find('string(//g:header/g:operationName)'),

      'validity' => (val = mdoc.find('string(//g:header/g:validity)')) == '' ? 'NOW' : val,

      'time' => Time.now.to_s

    }

 

    rules = Worker.new(mdoc).process_message

    id = nil

    if meta['validity'] == 'UNTIL'

      Dir.glob(File.dirname(__FILE__) + "/messages/*/meta").each do |f|

        tmeta = JSON.parse(File.read(f))

        if tmeta['source'] == meta['source'] && tmeta['op'] == meta['op'] && tmeta['validity'] == meta['validity']

          id = File.basename(File.dirname(f))

        end  

      end

    end  

    if (meta['validity'] == 'FOREVER' && rules.empty?) || (meta['validity'] == 'UNTIL' && id.nil?)

      begin

        id = id.nil? ? 0 : id + 1

        Dir.mkdir(File.dirname(__FILE__) + "/messages/#{id}")

      rescue SystemCallError

        retry

      end

    end

 

    if id

      File.write(File.dirname(__FILE__) + "/messages/#{id}/meta", JSON.pretty_generate(meta))

      File.write(File.dirname(__FILE__) + "/messages/#{id}/xml", mdoc.to_s)

    end

    rules.each do |r|

      to = JSON.parse(File.read(File.dirname(__FILE__) + "/rules/#{r}/meta"))

      client = Riddl::Client.interface("xmpp://" + to['source'], "callback.xml", :xmpp => @env['xmpp'])

      client.put Riddl::Parameter::Complex.new("gatewayResponse","text/xml",mdoc.to_s)

      Worker.new('rule',r).delete if mdoc.find('string(//g:header/g:commandSequence)') == 'LAST'

    end

    nil

  end

end #}}}

 

class RuleList < Riddl::Implementation #{{{

  def response

    Riddl::Parameter::Complex.new("result","application/json",JSON::pretty_generate(Worker.new('rules').list))

  end

end #}}}

class MessageList < Riddl::Implementation #{{{

  def response

    Riddl::Parameter::Complex.new("result","application/json",JSON::pretty_generate(Worker.new('messages').list))

  end

end #}}}

class RuleDetails < Riddl::Implementation #{{{

  def response

    if (det = Worker.new('rule',@r[-1]).details).nil?

      @status = 404

    else  

      Riddl::Parameter::Complex.new("gatewayRequest","text/xml",det)

    end  

  end

end #}}}

class MessageDetails < Riddl::Implementation #{{{

  def response

    if (det = Worker.new('message',@r[-1]).details).nil?

      @status = 404

    else  

      Riddl::Parameter::Complex.new("gatewayResponse","text/xml",det)

    end  

  end

end #}}}

class RuleDelete < Riddl::Implementation #{{{

  def response

    @status = 404 if Worker.new('rule',@r[-1]).delete.nil?

  end

end #}}}

class MessageDelete < Riddl::Implementation #{{{

  def response

    @status = 404 if Worker.new('message',@r[-1]).delete.nil?

  end

end #}}}

 

class Command < Riddl::Implementation

  ECMDS = %w{list details delete correlate help}

H_list = <<-end #{{{

(rules|messages)

  List all request and possible responses

end

#}}}

H_help = <<-end #{{{

 

  Show this.

end

#}}}

 H_details = <<-end #{{{

(rule|message) ID

  Send the contents of one of the listed request or response messages. If

  second argument is omitted, details for request messages are shown.

end

#}}}

H_delete = <<-end #{{{

(rule|message) ID

  Delete one of the request messages - this answers with an empty response

  (LAST).

  Example: delete rule 1

end

#}}}

H_correlate = <<-end #{{{

RULE-ID MESSAGE-ID

  Manually correlate a rule to a message. While correlation is typically

  automatic according to the parameters of the rule, this command can be used

  to manually send back a message to execution.

  The message is deleted according to normal NOW/UNTIL/FOREVER rules.

  Example: correlate 1 2

end

#}}}

 

  def response

    cmd = @p.shift.value

    para = @p.map{|x|x.value}

    res = case cmd

      when 'commands'

        ECMDS

      when 'help'

        ECMDS.flatten.map do |m|

          h = self.class.const_defined?("H_#{m}".to_sym) ? self.class.const_get("H_#{m}".to_sym) : "\n"

          "#{m.to_s.red.bold} #{h}"

        end.join

      when 'correlate'  

        n1 = File.dirname(__FILE__) + "/rules/#{para[0].to_i}/meta"

        n2 = File.dirname(__FILE__) + "/messages/#{para[1].to_i}/xml"

        if para.length == 2 && File.exists?(n1) && File.exists?(n2)

          to = JSON.parse(File.read(n1))

          data = File.read(n2)

          client = Riddl::Client.interface("xmpp://" + to['source'], "callback.xml", :xmpp => @env['xmpp'])

          client.put Riddl::Parameter::Complex.new("gatewayResponse","text/xml",data)

          doc = XML::Smart.string(data)

          doc.register_namespace 'g', 'http://www.fp7-adventure.eu/xmlSchema/Gateways/'

          Worker.new('rule',para[0]).delete if doc.find('string(//g:header/g:commandSequence)') == 'LAST'

          Worker.new('message',para[1]).delete if ['NOW','FOREVER'].include?(doc.find('string(//g:header/g:validity)'))

        end  

        nil

      when 'list'

        Worker.new(*para).list

      when 'details'

        Worker.new(*para).details

      when 'delete'

        Worker.new(*para).delete

      else

        "that's not a valid command"

    end || []

    res = [res] unless res.is_a?(Hash) || res.is_a?(Array)

    Riddl::Parameter::Complex.new("result","application/json",JSON::generate(res))

  end

end

 

Riddl::Server.new(File.dirname(__FILE__) + '/correlation.xml', :port => 9301) do

  xmpp '[email protected]', 'adventure_correlation'

  accessible_description true

  cross_site_xhr true

 

  on resource do

    run RuleProcess if post 'gateway-request'

    run MessageProcess if put 'gateway-response'

    run Command if put 'command'

    on resource 'rules' do

      run RuleList if get

      on resource do

        run RuleDetails if get

        run RuleDelete if delete

      end

    end

    on resource 'messages' do

      run MessageList if get

      on resource do

        run MessageDetails if get

        run MessageDelete if delete

      end

    end

  end

end.loop!