soba-mieruka 0.0.2

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.rspec

@@ -0,0 +1 @@
+--color --format d

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in soba-mieruka.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/soba/mieruka.rb

@@ -0,0 +1,330 @@
+# code: utf-8
+
+require 'digest/md5'
+require 'cgi'
+require 'net/http'
+require 'pathname'
+mieruka_dir = Pathname(File.dirname(__FILE__)) + 'mieruka'
+require mieruka_dir + 'user'
+require mieruka_dir + 'session'
+require mieruka_dir + 'room'
+require mieruka_dir + 'group'
+require mieruka_dir + 'version'
+
+module Soba
+  
+  class ApiResponse
+
+    attr_reader :doc, :error_code, :error_message
+    
+    def initialize(res)
+      @ok = false
+      if res.message == 'OK'
+        @doc = REXML::Document.new(res.body)
+        if @doc.root.attributes['result'] == 'OK'
+          @ok = true
+        else
+          errorElm = @doc.root.elements['error']
+          @error_code = errorElm.attributes['code'].to_i
+          @error_message = CGI.unescapeHTML(errorElm.attributes['message'])
+        end
+      end
+    end
+
+    def ok?
+      return @ok
+    end
+    
+  end
+
+  class ApiError < StandardError
+    def initialize(response)
+      @error_code = response.error_code
+      @error_message = response.error_message
+    end
+    attr_reader :error_code, :error_message
+  end
+  
+  
+  class Mieruka
+    
+    DEFAULT_CONFIG = {
+      :api_key => '',
+      :private_key => '',
+      :host => 'web-api.soba-project.com',
+      :port => 80,
+      :base_path => '/webapi',
+      :version => 1.4
+    }
+
+    def initialize(params)
+      @params = DEFAULT_CONFIG.merge(params)
+      @params[:base_path] += '/' + @params[:version].to_s unless @params[:version].nil?
+    end
+
+    attr_reader :token
+
+    # Returns the URL of the application's authentication page.
+    def authentication_url(back_url)
+      timestamp = Time.now.to_i.to_s
+      sig_base = @params[:private_key] + @params[:api_key] + back_url + timestamp
+      sig = Digest::MD5.new(sig_base)
+      enc_url = CGI.escape(back_url)
+      "#{$HTTPS_API_ROOT}/auth?api_key=#{@params[:api_key]}&back_url=#{enc_url}&time=#{timestamp}&sig=#{sig}"
+    end
+
+    def login(params)
+      required_params params, :user_name, :password
+      http = ::Net::HTTP.start(@params[:host], @params[:port])
+      path = @params[:base_path] + '/login'
+      val = "api_key=#{@params[:api_key]}&user_name=#{CGI.escape(params[:user_name])}&password=#{params[:password]}"
+      response = http.post(path, val)
+      make_response(response) do |doc, res|
+        @token = CGI.unescapeHTML(doc.root.elements["token"].get_text.to_s)
+      end
+    end
+    
+    def logout
+      # Returns a Command object
+      response = request_with_auth(:GET, '/logout')
+      make_response(response) do |doc, res|
+        url = CGI.unescapeHTML(doc.root.elements["url"].get_text.to_s)
+      end
+    end
+
+    def create_session(params)
+      required_params params, :session_name, :session_description
+      response = request_with_auth(:POST, '/create_session', params)
+      make_response(response) do |doc, res|
+        Struct.new(:url, :soba_session_id).new(
+          CGI.unescapeHTML(doc.root.elements["url"].get_text.to_s),
+          CGI.unescapeHTML(doc.root.elements["soba-session-id"].get_text.to_s)
+        )
+      end
+    end
+
+    def join_session(params)
+      required_params params, :session_id
+      sid = CGI.escape(params['session_id'])
+      response = request_with_auth(:GET, "/join_session?session_id=#{sid}")
+      puts response.body
+      make_response(response) do |doc, res|
+        Struct.new(:url).new(CGI.unescapeHTML(doc.root.elements["url"].get_text.to_s))
+      end
+    end
+
+    def sessions
+      # Returns an Array of Session object
+      response = request_with_auth(:GET, "/session_list")
+      make_response(response) do |doc, res|
+        doc.elements.collect('session-list-response/session-list/session') do |elm|
+          Session.create_from_session_element(elm)
+        end
+      end
+    end
+
+    def users
+      # Returns an Array of User object
+      response = request_with_auth(:GET, "/user_list")
+      #puts response.body
+      make_response(response) do |doc, res|
+        doc.elements.collect('user-list-response/user') do |elm|
+          User.create_from_element(elm)
+        end
+      end
+    end
+    
+    def change_password(new_password)
+      response = request_with_auth(:POST, '/change_password', :newPassword => new_password)
+      make_response(response)
+    end
+
+    def get_command(session_url)
+      # Returns a Command object which contains a URL to create or join the session
+      take_action(GetCommand)
+    end
+    
+    def rooms(params={})
+      response = request_with_auth(:GET, '/rooms', params)
+      make_response(response) do |doc, res|
+        doc.elements.collect('*/room') do |elm|
+          Room.create_from_room_element(elm)
+        end        
+      end
+    end
+    
+    def create_room(params)
+      required_params params, :name, :description
+      response = request_with_auth(:POST, '/create_room', params)
+      make_response(response) do |doc, res|
+        Room.create_from_room_element(doc.root.elements['room'])
+      end
+    end
+
+    def delete_room(rid)
+      response = request_with_auth(:GET, "/delete_room?rid=%s" % rid.to_s)
+      make_response(response)
+    end
+
+    def groups(params={})
+      response = request_with_auth(:GET, '/groups', params)
+      make_response(response) do |doc, res|
+        doc.elements.map('*/group') do |elm|
+          res.groups << Group.create_from_element(elm)
+        end        
+      end
+    end
+
+    def update_user_info(params)
+      #take_action(UpdateUserInfo, params)
+      res = request_with_auth(:GET, '/update_user_info', params)
+      return ApiResponse.new(res)
+    end
+    
+    def command_file(params)
+      required_params params, :rid
+      auth = CGI.escape(Mieruka.auth_header(@token, @params[:private_key]))
+      return "http://#{@params[:host]}#{@params[:base_path]}/command.mkd?rid=#{params[:rid]}&auth=#{auth}"
+    end
+
+    def create_group(params)
+      required_params params, :groupName, :groupDescription, :groupAdminName, :groupAdminPassword, :mailAddress
+      res = request_with_auth(:POST, '/create_group', params)
+      return ApiResponse.new(res)
+    end
+
+    def create_group_member(params)
+      required_params params, :newUserName, :newUserPassword, :nickname, :groupName, :groupAdminName, :groupAdminPassword
+      res = request_with_auth(:POST, '/create_group_member', params)
+      return ApiResponse.new(res)
+    end
+
+    def delete_group_member(params)
+      required_params params, :userName, :groupName, :groupAdminName, :groupAdminPassword
+      res = request_with_auth(:POST, '/delete_group_member', params)
+      ApiResponse.new(res)
+    end
+    
+    def set_pap_layout(layout)
+      response = request_with_auth(:POST, '/set_pap_layout', :layout => layout)
+      puts response.code
+      make_response(response)
+    end
+    
+    def get_license_usage
+      response = request_with_auth(:GET, '/get_license_usage')
+      make_response(response) do |doc, res|
+        class << res
+          attr_accessor :group, :max, :used
+        end
+        res.group = CGI.unescape(doc.root.elements['group'].get_text.to_s)
+        res.max = doc.root.elements['max'].get_text.to_s.to_i
+        res.used = doc.root.elements['used'].get_text.to_s.to_i
+      end
+    end
+    
+    def set_number_of_licenses(val)
+      response = request_with_auth(:GET, "/set_number_of_licenses?value=#{val}")
+      make_response(response)
+    end
+
+    #
+    # Private Methods
+    #
+    
+    private
+
+    def make_response(http_response, &block)
+      if http_response.message == 'OK'
+        res = ApiResponse.new(http_response)
+        if res.ok?
+          if block
+            block.call(res.doc, res)
+          end
+        else
+          raise ApiError.new(res)
+        end
+      else
+        raise http_response.message
+      end      
+    end
+
+    def request_with_auth(method, path, params={})
+      http = Net::HTTP.start(@params[:host], @params[:port])
+      req = nil
+      real_path = @params[:base_path] + path
+      #params[:auth] = Mieruka.auth_header(@token, @params[:private_key])
+      case method
+      when :GET
+        req = Mieruka::make_get_request(real_path, params)
+      when :POST
+        req = Mieruka::make_post_request(real_path, params)
+      else
+        raise 'Invalid method: ' + method
+      end
+      req['Authorization'] = Mieruka.auth_header(@token, @params[:private_key])
+      http.request(req)
+    end
+
+    #
+    # Helper Methods
+    #
+    
+    def self.make_get_request(path, params={})
+      query_params = Mieruka.make_params_string(params)
+      path += '?' + query_params if query_params.length > 0
+      return Net::HTTP::Get.new(path)
+    end
+
+    def self.make_post_request(path, params)
+      req = Net::HTTP::Post.new(path)
+      req.body = Mieruka.make_params_string(params)
+      req.content_type = 'application/x-www-form-urlencoded'
+      return req
+    end
+
+    def self.make_params_string(params)
+      qparam = params.map do |k,v|
+        if v.class == Array
+          v.map{|e| Mieruka.make_param_string(k, e)}.join('&')
+        else
+          Mieruka.make_param_string(k, v)
+        end
+      end
+      return qparam.join('&')
+    end
+
+    def self.make_param_string(name, value)
+      CGI.escape(name.to_s) + '=' + CGI.escape(value.to_s)
+    end
+
+    #
+    # Authentication Utils
+    #
+    
+    def self.auth_header(token, private_key)
+      timestamp = Time.now.to_i.to_s
+      nonce = generate_nonce()
+      sig = Digest::MD5.hexdigest(private_key + timestamp + nonce)
+      "SobaAuth token=\"#{token}\" timestamp=\"#{timestamp}\" nonce=\"#{nonce}\" sig=\"#{sig}\" sigalg=\"SOBA-1\""
+    end
+
+    def self.generate_nonce
+      charset = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
+      ret = []
+      16.times { ret << charset[rand(charset.length)].chr }
+      ret.join
+    end
+    
+    def required_params(params, *keys)
+      missings = []
+      keys.each do |key|
+        missings << key unless params.has_key?(key)
+      end
+      raise "Missing parameters: " + missings.join(',') if missings.size > 0      
+    end
+
+  end
+
+
+end

data/lib/soba/mieruka/group.rb

@@ -0,0 +1,40 @@
+require 'rexml/document'
+require 'cgi'
+
+module Soba
+  class Mieruka
+
+    class Group
+      def initialize(params)
+        @name = params['name']
+        @description = params['description']
+      end
+
+      attr_reader :name, :description
+
+      def to_s
+        "{name:%s, desc:%s}" % [@name, @description]
+      end
+
+      def self.create_from_element(elm)
+        return Group.new(parse_group_elm(elm))
+      end
+
+      private
+    
+      ATTRS = ['name', 'description']
+
+      def self.parse_group_elm(elm)
+        params = {}
+        ATTRS.each do |a|
+          begin
+            params[a] = CGI.unescapeHTML(elm.elements[a].get_text.to_s)
+          rescue
+          end
+        end
+        params
+      end
+    end
+    
+  end
+end

data/lib/soba/mieruka/response.rb

@@ -0,0 +1,36 @@
+class Soba::Mieruka
+
+  class Response
+    OK = 'OK'
+    NG = 'NG'
+    
+    def self.parse(res_body)
+      doc = REXML::Document.new(res_body)
+      if doc.root.attributes['result'] == 'OK'
+        return Response.new(OK, doc)
+      else
+        errorElm = doc.root.elements['error']
+        res = Response.new(NG, nil)
+        res.error_code = errorElm.attributes['code']
+        res.error_message = CGI.unescapeHTML(errorElm.attributes['message'])
+        return res
+      end
+    end
+    
+    attr_accessor :error_code, :error_message
+
+    def initialize(result, value, message=nil)
+      @result = result
+      @value = value
+      @message = message
+    end
+
+    def success?
+      @result != NG
+    end
+
+    attr_reader :value, :message
+  end
+
+
+end

data/lib/soba/mieruka/room.rb

@@ -0,0 +1,64 @@
+require 'rexml/document'
+require 'cgi'
+
+module Soba
+  class Mieruka
+
+    class Room
+      def initialize(params)
+        @id = params['id']
+        @name = params['name']
+        @description = params['description']
+        @owner = params['owner']
+        @created_time = Time.at(params['created-time'].to_i / 1000)
+        #@deleted_time = params['deleted-time']
+        @group = params['group']
+        @url = params['url']
+      end
+
+      attr_reader :id, :name, :description, :owner, :created_time, :group, :url
+
+      def to_s
+        "{id:%d, name:%s, desc:%s, owner:%s, created-time:%s, url:%s}" % [@id, @name, @description, @owner, @created_time, @url]
+      end
+
+      def self.create(http_res)
+        #Room.elm_to_room(elm_room)
+        self.create_from_xml(http_res.body)
+      end
+
+      def self.create_from_xml(xml)
+        doc = REXML::Document.new(xml)
+        ret = []
+        doc.elements.each('*/room') do |e|
+          ret << Room.elm_to_room(e)
+        end
+        ret
+      end
+    
+      def self.create_from_room_element(elm)
+        return Room.new(parse_room_elm(elm))      
+      end
+
+      private
+    
+      def self.elm_to_room(elm)
+        Room.new(parse_room_elm(elm))
+      end
+
+      ATTRS = ['id', 'name', 'description', 'owner', 'created-time', 'group', 'url']
+
+      def self.parse_room_elm(elm)
+        params = {}
+        ATTRS.each do |a|
+          begin
+            params[a] = CGI.unescapeHTML(elm.elements[a].get_text.to_s)
+          rescue
+          end
+        end
+        params
+      end
+    end
+
+  end
+end

data/lib/soba/mieruka/session.rb

@@ -0,0 +1,61 @@
+require 'rexml/document'
+require 'cgi'
+
+module Soba
+  class Mieruka
+
+    class Session
+      def initialize(params)
+        @id = params['id']
+        @title = params['title']
+        @description = params['description']
+        @creator_id = params['creator-id']
+        @created_time = params['created-time']
+        @deleted_time = params['deleted-time']
+        @soba_session_id = params['soba-session-id']
+        @scope = params['scope']
+        @participants = params['participants']
+      end
+
+      attr_reader :id, :title, :description, :creator_id, :created_time, :deleted_time, :soba_session_id, :scope
+    
+      def self.create(http_res)
+        doc = REXML::Document.new(http_res.body)
+        ret = []
+        doc.elements.each('session-list-response/session-list/session') do |elm|
+          ret << Session.elm_to_session(elm)
+        end
+        ret
+      end
+    
+      def self.create_from_session_element(elm)
+        return Session.new(parse_session_elm(elm))
+      end
+    
+   
+      private
+    
+      def self.elm_to_session(elm)
+        Session.new(parse_session_elm(elm))
+      end
+
+      ATTRS = ['id', 'title', 'description', 'creator-id', 'created-time', 'deleted-time', 'soba-session-id', 'scope']
+
+      def self.parse_session_elm(elm)
+        params = {}
+        ATTRS.each do |a|
+          begin
+            params[a] = CGI.unescapeHTML(elm.elements[a].get_text.to_s )
+          rescue
+          end
+        end
+        params['participants'] = []
+        elm.elements.each('participants/participant') do |partElm|
+          params['participants'] << partElm.get_text.to_s
+        end
+        params
+      end
+    end
+
+  end
+end

data/lib/soba/mieruka/user.rb

@@ -0,0 +1,51 @@
+require 'rexml/document'
+
+module Soba
+  class Mieruka
+
+    class User
+      def initialize(params)
+        @name = params['name']
+        @id   = params['id']
+        @mail = params['mail']
+        @groups = params['groups']
+      end
+
+      attr_accessor :id, :name, :mail, :groups
+
+      def self.create(http_res)
+        doc = REXML::Document.new(http_res.body)
+        ret = []
+        doc.elements.each('user-list-response/user') do |elm|
+          ret << User.create_from_element(elm)
+        end
+        ret
+      end
+    
+      def self.create_from_element(elm)
+        return User.new(parse_user_elm(elm))      
+      end
+
+      def to_s
+        "{name=#{@name}, mail=#{@mail}, id=#{@id}, groups=#{@groups.join(',')}}"
+      end
+
+      private
+    
+      ATTRS = ['id', 'name', 'mail', 'groups']
+
+      def self.parse_user_elm(elm)
+        params = {}
+        ATTRS.each do |a|
+          if a == 'groups'
+            params['groups'] = elm.get_elements('groups/group').map{|e| e.get_text.to_s}
+          else
+            params[a] = elm.elements[a].get_text.to_s
+          end
+        end
+        params
+      end
+
+    end
+  end
+end

data/lib/soba/mieruka/version.rb

@@ -0,0 +1,5 @@
+module Soba
+  class Mieruka
+    VERSION = "0.0.2"
+  end
+end

data/soba-mieruka.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "soba/mieruka/version"
+
+Gem::Specification.new do |s|
+  s.name        = "soba-mieruka"
+  s.version     = Soba::Mieruka::VERSION
+  s.authors     = ["Takuji Shimokawa"]
+  s.email       = ["takuji.shimokawa@gmail.com"]
+  s.homepage    = "http://web-api.soba-project.com"
+  s.summary     = %q{SOBA mieruka Web API's client library}
+  s.description = %q{This library is for developing web sites which publish command files to create new sessions or to join them for SOBA mieruka Client application.}
+  s.rubyforge_project = "soba-mieruka"
+
+  s.files         = `git ls-files`.split("\n").delete_if{|e| e =~ /^spec\//}
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+end

data/spec/mieruka_spec.rb

@@ -0,0 +1,128 @@
+require_relative '../lib/soba/mieruka'
+
+CONFIG = {
+  :api_key => 'your api key',
+  :private_key => 'your private key',
+  #:version => '1.4'
+}
+
+ACCOUNT = {
+  :user_name => 'you soba mieruka account',
+  :password => 'your password'
+}
+
+def gen_str(len)
+  a = ('a'..'z').to_a + ('A'..'Z').to_a + ('0'..'9').to_a
+  Array.new(len){a[rand(a.size)]}.join
+end
+
+describe Soba::Mieruka do
+  before do
+    @m = Soba::Mieruka.new(CONFIG)
+  end
+  
+  def valid_account
+    ACCOUNT
+  end
+  
+  it 'can log in with valid attributes.' do
+    expect {
+      @m.login(valid_account)
+      @m.logout
+    }.should_not raise_error
+  end
+  
+  context 'is logged in' do
+    before do
+      expect {
+        @m.login(valid_account)
+      }.should_not raise_error
+    end
+    
+    it 'make a new session' do
+      expect {
+        session = @m.create_session(:session_name => 'test', :session_description => 'this is a test')
+        session.should respond_to(:url)
+        session.should respond_to(:soba_session_id)
+      }.should_not raise_error
+    end
+    
+    it 'get the session list' do
+      expect {
+        sessions = @m.sessions
+        sessions.should be_a(Array)
+        sessions.each do |session|
+          session.should be_a(Soba::Mieruka::Session)
+          session.should respond_to(:id)
+          session.should respond_to(:title)
+          session.should respond_to(:description)
+          session.should respond_to(:creator_id)
+          session.should respond_to(:created_time)
+          session.should respond_to(:deleted_time)
+          session.should respond_to(:soba_session_id)
+          session.should respond_to(:scope)
+          session.should respond_to(:participants)
+        end
+      }.should_not raise_error
+    end
+    
+    it 'can get users list' do
+      expect {
+        users = @m.users
+        users.should be_a(Array)
+        users.each do |user|
+          user.should be_a(Soba::Mieruka::User)
+        end
+      }.should_not raise_error
+    end
+    
+    context 'and some sessions exist' do
+      before do
+        @sessions = @m.sessions
+      end
+      
+      it 'can join the session' do
+        pending('No sessions exist!') if @sessions.empty?
+        @session = @sessions[0]
+        res = @m.join_session(:session_id => @session.id)
+      end
+    end
+    
+    it 'can get rooms' do
+      rooms = @m.rooms
+      rooms.should be_a(Array)
+    end
+    
+    it 'can create and delete a room' do
+      rooms = @m.rooms
+      rooms.class.should == Array
+      n = rooms.size
+      
+      name = 'room_' + gen_str(10)
+      room = @m.create_room(:name => name, :description => 'test room')
+      room.name.should == name
+      room.description.should == 'test room'
+      rooms = @m.rooms
+      rooms.size.should == (n + 1)
+
+      expect {
+        @m.delete_room(room.id)
+      }.should_not raise_error
+      @m.rooms.size.should == n
+    end
+    
+    it 'can change its own password' do
+      old_password = valid_account[:password]
+      new_password = gen_str(16)
+      expect {
+        @m.change_password(new_password)
+        @m.login(valid_account.merge(:password => new_password))
+        @m.change_password(old_password)
+      }.should_not raise_error
+      expect {
+        @m.login(valid_account.merge(:password => new_password))
+      }.should raise_error
+    end
+  end
+  
+end

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification
+name: soba-mieruka
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Takuji Shimokawa
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-12-15 00:00:00.000000000Z
+dependencies: []
+description: This library is for developing web sites which publish command files
+  to create new sessions or to join them for SOBA mieruka Client application.
+email:
+- takuji.shimokawa@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- Rakefile
+- lib/soba/mieruka.rb
+- lib/soba/mieruka/group.rb
+- lib/soba/mieruka/response.rb
+- lib/soba/mieruka/room.rb
+- lib/soba/mieruka/session.rb
+- lib/soba/mieruka/user.rb
+- lib/soba/mieruka/version.rb
+- soba-mieruka.gemspec
+- spec/mieruka_spec.rb
+homepage: http://web-api.soba-project.com
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: soba-mieruka
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: SOBA mieruka Web API's client library
+test_files:
+- spec/mieruka_spec.rb
+has_rdoc: