ecircle_soap_client 0.0.5

data/lib/ecircle/configuration.rb

@@ -0,0 +1,14 @@
+require 'ostruct'
+module Ecircle
+  class Configuration
+    attr_accessor :realm, :user, :password, :wsdl
+
+    def initialize
+      @session_token = nil
+      @wsdl = OpenStruct.new
+      wsdl.document = "http://webservices.ecircle-ag.com/soap/ecm.wsdl"
+      wsdl.endpoint = "http://webservices.ecircle-ag.com/rpc"
+      wsdl.namespace = "http://webservices.ecircleag.com/rpcns"
+    end
+  end
+end

data/lib/ecircle/group.rb

@@ -0,0 +1,73 @@
+module Ecircle
+  class Group < Ecircle::Base
+    class << self
+      def find_all_by_name(group_name)
+        ary = Ecircle.client.lookup_groups :lookupParams => { :groupName => group_name }
+        ary.is_a?(Array) ? ary.collect { |a| Ecircle::Group.new(a) } : []
+      end
+
+      def find_by_name(group_name)
+        hsh = Ecircle.client.lookup_groups :lookupParams => { :groupName => group_name }
+        hsh.is_a?(Hash) ? Group.new(hsh) : raise("Group name #{group_name} not unique")
+      end
+
+      def all
+        find_all_by_name("")
+      end
+
+      def find_by_id(idstr)
+        ## TODO there must be a better way of doing this?!
+        ## TODO but there isn't a lookupGroupById in the wsdl specification.
+        all.reject { |a| a.id != idstr }.first
+      end
+    end
+
+    def initialize(hsh = nil)
+      super()
+      @all_fields = hsh || {}
+      @id = self[:id]
+    end
+
+    # Make a user a member of a group. Can be called multiple times for the same
+    # user, eCircle checks for duplicates based on the email or whatever.
+    # Returns a member object.
+    def add_member(user, send_invite = false, send_message = false)
+      member_id = Ecircle.client.
+        create_member(:userId  => user.id,     :groupId     => @id,
+                      :invite  => send_invite, :sendMessage => send_message)
+      Ecircle::Member.find_by_id(member_id)
+    end
+
+    def remove_user(user, send_message = false)
+      user.leave_group(self, send_message)
+    end
+
+    def remove_member(member, send_message = false)
+      member.user.leave_group(self, send_message)
+    end
+
+    # clone this group at eCircle. For example,
+    #     Ecircle::Group.
+    #       find_by_name("fubar").
+    #       clone( "snafu", "snafu@cmXX.ecircle-ag.com", false )
+    def clone(with_name, with_email, keep_owner = true)
+      Ecircle.client.
+        clone_group(:templateGroupId => @id, :newGroupEmail => with_email,
+                    :newGroupName => with_name, :keepOwner => keep_owner)
+    end
+
+    def delete
+      Ecircle.client.delete_group :groupId => @id
+    end
+
+    def to_xml
+      # prefer to use u.send(...) but that creates a new xml element called 'send'!
+      # hence this is using instance_eval with a string.
+      Savon::SOAP::XML.new.xml do |x|
+        x.group(:id => @id) do |u|
+          u.name(@id)
+        end
+      end
+    end
+  end
+end

data/lib/ecircle/member.rb

@@ -0,0 +1,31 @@
+module Ecircle
+  class Member < Ecircle::Base
+    class << self
+      def find_by_id(member_id)
+        Ecircle.client.lookup_member_by_id :memberid => member_id
+      end
+    end
+
+    def initialize(xml_string)
+      super()
+      init_with_xml("member", xml_string)
+    end
+
+    def delete
+      Ecircle.client.delete_member :memberId => @id
+    end
+
+    ## TODO with assume that the member id is the form of "<userid>g<groupid>", hence
+    ## TODO split on 'g' should work!
+    def user_id  ; @id.split(/g/).first ; end
+    def group_id ; @id.split(/g/).last ; end
+
+    def group
+      Ecircle::Group.find_by_id(group_id)
+    end
+    def user
+      Ecircle::User.find_by_id(user_id)
+    end
+
+  end
+end

data/lib/ecircle/message.rb

@@ -0,0 +1,93 @@
+module Ecircle
+  class Message < Ecircle::Base
+
+    MessageTypeUnknown = Class.new(RuntimeError)
+    MessageGroupNotDefined = Class.new(RuntimeError)
+
+    class << self
+      def find_all_by_group_name(group_name)
+        ary = Ecircle.client.lookup_messages :lookupParams => { :groupName => group_name }
+        ary.is_a?(Array) ? ary.collect { |a| Ecircle::Message.new(a) } : []
+      end
+
+      def find_by_id(idstr)
+        ## TODO no lookupMessageById, hence this workaround.
+        all.reject { |msg| msg.id != idstr }.first
+      end
+
+      def all
+        find_all_by_group_name("")
+      end
+    end
+
+    def initialize(hsh)
+      super()
+      @all_fields = hsh
+      @id = self[:id]
+    end
+
+    def subject
+      self[:subject]
+    end
+
+    def group
+      # a single message could potentially have no group_id? Either case this
+      # should just return nil instead of raising an exception.
+      Ecircle::Group.find_by_id(self[:group_id]) if self[:group_id]
+    end
+
+    def delete
+      Ecircle.client.delete_message :messageId => self.id
+      true
+    rescue Ecircle::Client::PermissionDenied => e
+      false
+    end
+
+    # This does one of two things, if the message is of type 'single', then
+    # it uses send_single_message_to_user, else if the type is 'normal' then
+    # it uses the send_group_message_to_user.
+    #
+    # If parameters are given and this is a single message, then a parameterized
+    # version of the message is sent.
+    #
+    # Return value is an array with the first value being boolean to indicate
+    # success status. The second value is the original result returned by the
+    # ecircle API. The thing is, that ecircle will return nil on success, so
+    # in that case, we return [true, nil].
+    def send_to_user(user, parameters = nil)
+      result = case self[:type]
+
+               when /single/
+                 if parameters.nil?
+                   Ecircle.client.
+                     send_single_message_to_user(:singleMessageId => @id,
+                                                 :userId => user.id)
+                 else
+                   paras = { :singleMessageId => @id,
+                             :userId          => user.id,
+                             :names           => parameters.keys,
+                             :values          => parameters.values,
+                           }
+                   Ecircle.client.send_parametrized_single_message_to_user(paras)
+                 end
+
+               when /normal/
+                 # raise an exception because this is inconsistent: a group message without
+                 # group_id is not possible.
+                 raise MessageGroupNotDefined, "MsgId: #{self.id}" unless self[:group_id]
+
+                 Ecircle.client.
+                   send_group_message_to_user(:userId    => user.id,
+                                              :messageId => @id,
+                                              :groupid   => self[:group_id])
+               else
+                 raise(MessageTypeUnknown, "Type: #{self[:type]} unknown for "+
+                       "MsgId: #{self.id}")
+               end
+
+      # strangely, if the message sending worked out, then ecircle sends nil, i.e.
+      # nothing back. Else we get some sort of strange error or exception.
+      result.nil? ? [true, nil] : [false, result]
+    end
+  end
+end

data/lib/ecircle/user.rb

@@ -0,0 +1,120 @@
+module Ecircle
+  class User < Ecircle::Base
+
+    class << self
+      def create_by_email(email)
+        u = User.new
+        u.email = email
+        ## TODO why must the title be defined
+        u.title = "-1"
+        u.id = Ecircle.client.create_user :userXmlSpec => u.to_xml
+        u
+      end
+
+      def find_by_email(email)
+        Ecircle.client.lookup_user_by_email :email => email
+      end
+
+      def find_by_identifier(idstr)
+        Ecircle.client.lookup_user_by_identifier :identifier => idstr
+      end
+
+      def find_by_id(idstr)
+        Ecircle.client.lookup_user_by_id :userId => idstr
+      end
+    end
+
+    def initialize(xml_string = nil)
+      super()
+      initialize_with_xml(xml_string) if xml_string
+    end
+
+    def email
+      self[:email]
+    end
+
+    def delete
+      Ecircle.client.delete_user :user_id => @id
+    end
+
+    def create_or_update(send_message = false)
+      Ecircle.client.
+        create_or_update_user_by_email :userXml => to_xml, :sendMessage => send_message
+    end
+
+    def save
+      Ecircle.client.update_user :userXmlSpec => to_xml
+    end
+
+    # Returns the group ids this user is signed up to as an Array of strings.
+    def group_ids
+      [Ecircle.client.find_memberships_by_email(:email => email)].flatten.compact
+    end
+
+    def groups
+      group_ids.collect { |grpid| Ecircle::Group.find_by_id(grpid) }
+    end
+    alias_method :memberships, :groups
+
+    # +group_or_id+ may be a Ecircle::Group
+    # object, containing the group's id, or the id directly.
+    def in_group?(group_or_id)
+      group_ids.include?(Ecircle::User.group_id(group_or_id))
+    end
+
+    def join_group(group, send_invite = false, send_message = false)
+      group.add_member self, send_invite, send_message
+    end
+
+    # Unsubscribe this user from the given group. group may be a Ecircle::Group
+    # object, containing the group's id, or the id directly.
+    # Always returns true.
+    def leave_group(group_or_id, send_message = false)
+      Ecircle.client.
+        unsubscribe_member_by_email(:groupId     => Ecircle::User.group_id(group_or_id),
+                                    :email       => email,
+                                    :sendMessage => send_message)
+    end
+
+    def to_xml
+      obj = self # in instance_eval 'self' will be something else, so create new
+                 # reference to te self containing all the data.
+
+      # prefer to use u.send(...) but that creates a new xml element called 'send'!
+      # hence this is using instance_eval with a string.
+      Savon::SOAP::XML.new.xml do |x|
+        x.user(:id => @id) do |u|
+          # email is special, so so so special.
+          u.email(self.email)
+
+          # base attributes of a user
+          [:title, :firstname, :lastname, :nickname, :dob_dd,
+           :dob_mm, :dob_yyyy,:countrycode,:languagecode].each do |field_name|
+            u.instance_eval "%s(obj[:%s])" % ([field_name]*2)
+          end
+
+          # cust_attr_X
+          9.times.collect { |idx| "cust_attr_#{idx+1}" }.
+            each do |field_name|
+            u.instance_eval "%s(obj[:%s])" % ([field_name]*2)
+          end
+
+          # named attributes, these are generic and defined by some guy in a suit.
+          named_attrs.each do |key,value|
+            u.namedattr({:name => key}, value)
+          end
+        end
+      end
+    end
+
+    private
+
+    def self.group_id(group_obj_or_id)
+      (group_obj_or_id.is_a?(Ecircle::Group) ? group_obj_or_id.id : group_obj_or_id).to_s
+    end
+
+    def initialize_with_xml(xml_string)
+      init_with_xml("user", xml_string)
+    end
+  end
+end

data/lib/ecircle_soap_client.rb

@@ -0,0 +1,48 @@
+require 'savon'
+require 'nokogiri'
+require 'net/http/post/multipart'
+require 'uuidtools'
+require 'base64'
+require 'ostruct'
+
+require 'ecircle/configuration'
+require 'ecircle/client'
+require 'ecircle/base'
+require 'ecircle/member'
+require 'ecircle/group'
+require 'ecircle/user'
+require 'ecircle/message'
+
+# Helper for converting times to ecircle expected format.
+module EcircleTimeHelper
+  def ecircle_format(prefix)
+    # ecircle uses JS month indices
+    strftime("yyyy:%Y,dd:%d,hh:%H,min:%M,ss:%S,mm:#{'%02d' % (month - 1)}").split(',').
+      inject({}) do |hsh, postfix_and_value|
+      postfix, value = postfix_and_value.split(':')
+      hsh.merge( "#{prefix}_#{postfix}".to_sym => value )
+    end
+  end
+end
+
+[Date, Time].each do |clazz|
+  clazz.send(:include, EcircleTimeHelper)
+end
+
+module Ecircle
+  extend self
+
+  def configuration
+    @configuration ||= Configuration.new
+  end
+
+  def client
+    @client ||= Client.new
+  end
+
+  def configure
+    config = configuration
+    block_given? ? yield(config) : config
+    config
+  end
+end

data/start_pry_with_ecircle

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+# -*- ruby -*-
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+original_load_path = $LOAD_PATH
+dirs = ['ext', 'lib'].select { |dir| File.directory?(dir) }
+$LOAD_PATH.unshift(*dirs)
+
+require 'pry'
+require 'ecircle_soap_client'
+
+settings = YAML::load_file(File.join(File.dirname(__FILE__), 'test', '.login.yml'))
+Ecircle.configure do |config|
+  config.user     = settings["user"]
+  config.realm    = settings["realm"]
+  config.password = settings["password"]
+end
+puts "*** Setup Ecircle"
+
+Pry.editor = "emacs"
+Pry.start
+
+$LOAD_PATH.reject! { |path| !(original_load_path.include?(path)) }

data/test/.login.yml.sample

@@ -0,0 +1,4 @@
+---
+user: username
+realm: http://example.com
+password: password

data/test/helper.rb

@@ -0,0 +1,116 @@
+require 'rubygems'
+require 'bundler'
+
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+require 'test/unit'
+require 'shoulda'
+require 'yaml'
+require 'rr'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'ecircle_soap_client'
+
+class Test::Unit::TestCase
+  include RR::Adapters::TestUnit
+
+  def _soap_fault(msg)
+    os = OpenStruct.new
+    os.body = Savon::SOAP::XML.new.xml do |x|
+      x.envelope do |e|
+        e.body do |b|
+          b.Fault do |f|
+            f.faultcode("client")
+            f.faultstring(msg)
+          end
+        end
+      end
+    end
+    Savon::SOAP::Fault.new(os)
+  end
+
+  def mock_ecircle_client(create_client_object = false)
+    if create_client_object
+      client, req_obj = Ecircle::Client.new, Object.new
+      mock(client).client { req_obj }
+      # don't mock client since this will be used directly.
+      yield(client, mock(req_obj))
+    else
+      req_object = Object.new
+      mock(Ecircle).client { req_object }
+      yield(mock(req_object))
+    end
+  end
+
+  def in_soap_body
+    <<-SOAP
+     <?xml version="1.0" encoding="UTF-8"?>
+      <soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+        <soapenv:Body>
+         #{yield}
+        </soapenv:Body>
+      </soapenv:Envelope>
+    SOAP
+  end
+
+  def mock_response(resp)
+    mock_ecircle_client(true) do |client, savon_client|
+      mock(Ecircle).client { client }
+      mock(client).logon { nil }
+      savon_client.request.with_any_args do
+        Savon::SOAP::Response.new(HTTPI::Response.new(200, {}, resp))
+      end
+    end
+  end
+
+  def config_soap_client
+    # keep login details separate from gem.
+    settings = begin
+                 YAML::load_file(File.join(File.dirname(__FILE__), '.login.yml'))
+               rescue
+                 puts "NO test/.login.yml --> copy the sample across to test"
+                 exit 1
+               end
+
+    Ecircle.configure do |config|
+      config.user     = settings["user"]
+      config.realm    = settings["realm"]
+      config.password = settings["password"]
+    end
+  end
+
+  def assert_difference(expression, difference = 1, message = nil, &block)
+    b = block.send(:binding)
+    exps = Array.wrap(expression)
+    before = exps.map { |e| eval(e, b) }
+
+    yield
+
+    exps.each_with_index do |e, i|
+      error = "#{e.inspect} didn't change by #{difference}"
+      error = "#{message}.\n#{error}" if message
+      assert_equal(before[i] + difference, eval(e, b), error)
+    end
+  end
+end
+
+# Rails extension required for assert_difference (another rails extension)
+class Array
+  def self.wrap(object)
+    if object.nil?
+      []
+    elsif object.respond_to?(:to_ary)
+      object.to_ary
+    else
+      [object]
+    end
+  end
+end