mp_weixin 0.1.0

data/lib/mp_weixin/models/message.rb

@@ -0,0 +1,227 @@
+# encoding: utf-8
+
+module MpWeixin
+  # The MpWeixin::Message class
+  #
+  class Message
+    include ActiveModel::Model
+    attr_accessor :ToUserName, :FromUserName,
+                    :CreateTime, :MsgType, :MsgId
+
+    # Instantiate a new Message with a hash of attributes
+    #
+    # @param [Hash] attributes the attributes value
+    def initialize(attributes = nil)
+      # Dynamic attr_accessible
+      # maybe cause secret problem
+      # singleton_class.class_eval do
+      #   attr_accessor *attributes.keys
+      # end
+
+      super
+      @source = ActiveSupport::HashWithIndifferentAccess.new(attributes)
+    end
+
+    # same as @attributes CreateTime of an Message instance
+    #
+    # @return [Integer]
+    def create_time
+      self.CreateTime.to_i
+    end
+    # alias :CreateTime :create_time
+
+    # convert create_time to an Time instance
+    #
+    # @return [Time]
+    def created_at
+      Time.at create_time rescue nil
+    end
+
+    def msg_id
+      self.MsgId.to_i
+    end
+
+    # initialize an ReplyMessage
+    # @msg_type [string] the MsgType of ReplyMessage
+    # @attributes [Hash] the attributes of ReplyMessage
+    # @return an instance of #{MsgType}ReplyMessage
+    def reply(msg_type, attributes)
+      if attributes.is_a?(Hash)
+        attributes = attributes.deep_symbolize_keys
+        attributes.reverse_merge!({
+          ToUserName: self.FromUserName,
+          FromUserName: self.ToUserName
+        })
+      end
+
+      case msg_type
+        when 'text'
+          MpWeixin::TextReplyMessage.new(attributes)
+        when 'image'
+          MpWeixin::ImageReplyMessage.new(attributes)
+        when 'voice'
+          MpWeixin::VoiceReplyMessage.new(attributes)
+        when 'video'
+          MpWeixin::VideoReplyMessage.new(attributes)
+        when 'music'
+          MpWeixin::MusicReplyMessage.new(attributes)
+        when 'news'
+          MpWeixin::NewsReplyMessage.new(attributes)
+        else
+          # raise 'Unknown Message data'
+      end
+    end
+
+    # initialize an TextReplyMessage
+    # @attributes [Hash] the attributes of TextReplyMessage
+    def reply_text_message(attributes)
+      reply("text", attributes)
+    end
+
+    # initialize an ImageReplyMessage
+    # @attributes [Hash] the attributes of ImageReplyMessage
+    def reply_image_message(attributes)
+      reply("image", attributes)
+    end
+
+    # initialize an VoiceReplyMessage
+    # @attributes [Hash] the attributes of VoiceReplyMessage
+    def reply_voice_message(attributes)
+      reply("voice", attributes)
+    end
+
+    # initialize an VideoReplyMessage
+    # @attributes [Hash] the attributes of VideoReplyMessage
+    def reply_video_message(attributes)
+      reply("video", attributes)
+    end
+
+    # initialize an MusicReplyMessage
+    # @attributes [Hash] the attributes of MusicReplyMessage
+    def reply_music_message(attributes)
+      reply("music", attributes)
+    end
+
+    # initialize an NewsReplyMessage
+    # @attributes [Hash] the attributes of NewsReplyMessage
+    def reply_news_message(attributes)
+      reply("news", attributes)
+    end
+
+    class << self
+      def from_xml(xml)
+        begin
+          hash = MultiXml.parse(xml)['xml']
+          message = case hash['MsgType']
+                      when 'text'
+                        TextMessage.new(hash)
+                      when 'image'
+                        ImageMessage.new(hash)
+                      when 'location'
+                        LocationMessage.new(hash)
+                      when 'link'
+                        LinkMessage.new(hash)
+                      when 'event'
+                        # EventMessage.new(hash)
+                        Event.from_xml(xml)
+                      when 'voice'
+                        VoiceMessage.new(hash)
+                      when 'video'
+                        VideoMessage.new(hash)
+                      else
+                        # raise 'Unknown Message data'
+                    end
+        rescue
+          logger.info('Unknown Message data #{xml}') if self.respond_to?(:logger)
+        end
+      end
+    end
+  end
+
+  #   <xml>
+  #     <ToUserName><![CDATA[toUser]]></ToUserName>
+  #     <FromUserName><![CDATA[fromUser]]></FromUserName>
+  #     <CreateTime>1348831860</CreateTime>
+  #     <MsgType><![CDATA[text]]></MsgType>
+  #     <Content><![CDATA[this is a test]]></Content>
+  #     <MsgId>1234567890123456</MsgId>
+  #   </xml>
+  # TextMessage = Class.new(Message)
+  class TextMessage < Message
+    attr_accessor :Content
+  end
+
+  #   <xml>
+  #     <ToUserName><![CDATA[toUser]]></ToUserName>
+  #     <FromUserName><![CDATA[fromUser]]></FromUserName>
+  #     <CreateTime>1348831860</CreateTime>
+  #     <MsgType><![CDATA[image]]></MsgType>
+  #     <PicUrl><![CDATA[this is a url]]></PicUrl>
+  #     <MsgId>1234567890123456</MsgId>
+  #   </xml>
+  # ImageMessage = Class.new(Message)
+  class ImageMessage < Message
+    attr_accessor :PicUrl, :MediaId
+  end
+
+  #   <xml>
+  #     <ToUserName><![CDATA[toUser]]></ToUserName>
+  #     <FromUserName><![CDATA[fromUser]]></FromUserName>
+  #     <CreateTime>1376632760</CreateTime>
+  #     <MsgType><![CDATA[voice]]></MsgType>
+  #     <MediaId><![CDATA[Qyb0tgux6QLjhL6ipvFZJ-kUt2tcQtkn0BU365Vt3wUAtqfGam4QpZU35RXVhv6G]]></MediaId>
+  #     <Format><![CDATA[amr]]></Format>
+  #     <MsgId>5912592682802219078</MsgId>
+  #     <Recognition><![CDATA[]]></Recognition>
+  #   </xml>
+  # VoiceMessage = Class.new(Message)
+  class VoiceMessage < Message
+    attr_accessor :MediaId, :Format
+  end
+
+  #   <xml>
+  #     <ToUserName><![CDATA[toUser]]></ToUserName>
+  #     <FromUserName><![CDATA[fromUser]]></FromUserName>
+  #     <CreateTime>1376632994</CreateTime>
+  #     <MsgType><![CDATA[video]]></MsgType>
+  #     <MediaId><![CDATA[TAAGb6iS5LcZR1d5ICiZTWGWi6-Upic9tlWDpAKcNJA]]></MediaId>
+  #     <ThumbMediaId><![CDATA[U-xulPW4kq6KKMWFNaBSPc65Bcgr7Qopwex0DfCeyQs]]></ThumbMediaId>
+  #     <MsgId>5912593687824566343</MsgId>
+  #   </xml>
+  # VideoMessage = Class.new(Message)
+  class VideoMessage < Message
+    attr_accessor :MediaId, :ThumbMediaId
+  end
+
+  #   <xml>
+  #     <ToUserName><![CDATA[toUser]]></ToUserName>
+  #     <FromUserName><![CDATA[fromUser]]></FromUserName>
+  #     <CreateTime>1351776360</CreateTime>
+  #     <MsgType><![CDATA[location]]></MsgType>
+  #     <Location_X>23.134521</Location_X>
+  #     <Location_Y>113.358803</Location_Y>
+  #     <Scale>20</Scale>
+  #     <Label><![CDATA[位置信息]]></Label>
+  #     <MsgId>1234567890123456</MsgId>
+  #   </xml>
+  # LocationMessage = Class.new(Message)
+  class LocationMessage < Message
+    attr_accessor :Location_X , :Location_Y, :Scale, :Label
+  end
+
+  #   <xml>
+  #     <ToUserName><![CDATA[toUser]]></ToUserName>
+  #     <FromUserName><![CDATA[fromUser]]></FromUserName>
+  #     <CreateTime>1351776360</CreateTime>
+  #     <MsgType><![CDATA[link]]></MsgType>
+  #     <Title><![CDATA[公众平台官网链接]]></Title>
+  #     <Description><![CDATA[公众平台官网链接]]></Description>
+  #     <Url><![CDATA[url]]></Url>
+  #     <MsgId>1234567890123456</MsgId>
+  #   </xml>
+  #
+  # LinkMessage = Class.new(Message)
+  class LinkMessage < Message
+    attr_accessor :Title , :Description, :Url
+  end
+end

data/lib/mp_weixin/models/reply_message.rb

@@ -0,0 +1,180 @@
+# encoding: utf-8
+
+module MpWeixin
+  class ReplyMessage
+    include ActiveModel::Model
+    include ROXML
+
+    xml_name :xml
+    #xml_convention :camelcase
+
+    attr_accessor :ToUserName, :FromUserName,
+                    :CreateTime, :MsgType
+
+    xml_accessor :ToUserName, :cdata => true
+    xml_accessor :FromUserName, :cdata => true
+    xml_reader :CreateTime, :as => Integer
+    xml_reader :MsgType, :cdata => true
+
+    def initialize(attributes = {})
+      super
+      @CreateTime ||= Time.now.to_i
+    end
+
+    def to_xml
+      super.to_xml(:encoding => 'UTF-8', :indent => 0, :save_with => 0)
+    end
+
+    class << self
+      def set_nested_attr(nested_attr_name)
+        # define_method(:hi) { puts "Hello World!" }
+        class_eval <<-STR
+          def #{nested_attr_name}=(nested_attr = [])
+            @#{nested_attr_name} = nested_attr.is_a?(#{nested_attr_name}) ? nested_attr : #{nested_attr_name}.new(nested_attr)
+          end
+        STR
+      end
+    end
+  end
+
+  class TextReplyMessage < ReplyMessage
+    # include ActiveModel::Model
+
+    attr_accessor :Content
+    xml_accessor :Content, :cdata => true
+
+    def initialize(attributes = {})
+      super
+      @MsgType ||= 'text'
+    end
+  end
+
+  class Image
+    include ActiveModel::Model
+    include ROXML
+
+    attr_accessor :MediaId
+    xml_accessor :MediaId
+
+    # other important functionality
+  end
+
+  class ImageReplyMessage < ReplyMessage
+    attr_accessor :Image
+    xml_accessor :Image, as: Image, :cdata => true
+
+    set_nested_attr :Image
+    def initialize(attributes = {})
+      super
+      @MsgType ||= 'image'
+    end
+
+  end
+
+  class Voice
+    include ActiveModel::Model
+    include ROXML
+
+    xml_accessor :MediaId
+
+    # other important functionality
+  end
+
+  class VoiceReplyMessage < ReplyMessage
+    attr_accessor :Voice
+    xml_accessor :Voice, as: Voice, :cdata => true
+    set_nested_attr :Voice
+
+    def initialize(attributes = {})
+      super
+      @MsgType ||= 'voice'
+    end
+
+  end
+
+  class Video
+    include ActiveModel::Model
+    include ROXML
+
+    attr_accessor :MediaId, :Title, :Description
+
+    xml_accessor :MediaId, :cdata => true
+    xml_accessor :Title, :cdata => true
+    xml_accessor :Description, :cdata => true
+
+  end
+
+  class VideoReplyMessage < ReplyMessage
+    attr_accessor :Video
+    xml_accessor :Video, as: Video, :cdata => true
+    set_nested_attr :Video
+
+    def initialize(attributes = {})
+      super
+      @MsgType ||= 'video'
+    end
+
+  end
+
+  class Music
+    include ActiveModel::Model
+    include ROXML
+
+    attr_accessor :Title, :Description, :MusicUrl, :HQMusicUrl, :ThumbMediaId
+
+    xml_accessor :Title, :cdata => true
+    xml_accessor :Description, :cdata => true
+    xml_accessor :MusicUrl, :cdata => true
+    xml_accessor :HQMusicUrl, :cdata => true
+    xml_accessor :ThumbMediaId, :cdata => true
+  end
+
+  class MusicReplyMessage < ReplyMessage
+    attr_accessor :Music
+    xml_accessor :Music, :as => Music
+    set_nested_attr :Music
+
+    def initialize(attributes = {})
+      super
+      @MsgType ||= 'music'
+    end
+
+  end
+
+  class Item
+    include ActiveModel::Model
+    include ROXML
+
+    attr_accessor :Title, :Description, :PicUrl, :Url
+    xml_accessor :Title, :cdata => true
+    xml_accessor :Description, :cdata => true
+    xml_accessor :PicUrl, :cdata => true
+    xml_accessor :Url, :cdata => true
+  end
+
+  class NewsReplyMessage < ReplyMessage
+    attr_accessor :ArticleCount, :Articles
+    xml_accessor :ArticleCount, :as => Integer
+    xml_accessor :Articles, :as => [Item], :in => 'Articles', :from => 'item'
+    set_nested_attr :Articles
+
+    def initialize(attributes = {})
+      super
+      @MsgType ||= 'news'
+    end
+
+    def Articles=(attributes)
+      _attributes = attributes.is_a?(Hash) ? attributes.deep_symbolize_keys[:item] : attributes.dup
+
+      @Articles = _attributes.collect do |item_attr|
+
+        if item_attr.is_a?(Item)
+          item_attr
+        else
+         item_attr = item_attr.deep_symbolize_keys
+         Item.new(item_attr)
+        end
+      end
+    end
+  end
+end

data/lib/mp_weixin/response.rb

@@ -0,0 +1,93 @@
+require 'multi_json'
+require 'rack'
+
+module MpWeixin
+  # MpWeixin::Response class
+  class Response
+    attr_reader :response
+    attr_accessor :error, :options
+
+    # Adds a new content type parser.
+    #
+    # @param [Symbol] key A descriptive symbol key such as :json or :query.
+    # @param [Array] One or more mime types to which this parser applies.
+    # @yield [String] A block returning parsed content.
+    def self.register_parser(key, mime_types, &block)
+      key = key.to_sym
+      PARSERS[key] = block
+      Array(mime_types).each do |mime_type|
+        CONTENT_TYPES[mime_type] = key
+      end
+    end
+
+    # Initializes a Response instance
+    #
+    # @param [Faraday::Response] response The Faraday response instance
+    # @param [Hash] opts options in which to initialize the instance
+    # @option opts [Symbol] :parse (:automatic) how to parse the response body.  one of :query (for x-www-form-urlencoded),
+    #   :json, or :automatic (determined by Content-Type response header)
+    def initialize(response, opts={})
+      @response = response
+      @options = {:parse => :automatic}.merge(opts)
+    end
+
+    # The HTTP response headers
+    def headers
+      response.headers
+    end
+
+    # The HTTP response status code
+    def status
+      response.status
+    end
+
+    # The HTTP response body
+    def body
+      response.body || ''
+    end
+
+    # Procs that, when called, will parse a response body according
+    # to the specified format.
+    PARSERS = {
+      # Can't reliably detect whether MultiJson responds to load, since it's
+      # a reserved word. Use adapter as a proxy for new features.
+      :json  => lambda{ |body| MultiJson.respond_to?(:adapter) ? MultiJson.load(body) : MultiJson.decode(body) rescue body },
+      :query => lambda{ |body| Rack::Utils.parse_query(body) },
+      :text  => lambda{ |body| body }
+    }
+
+    # Content type assignments for various potential HTTP content types.
+    CONTENT_TYPES = {
+      'application/json' => :json,
+      'text/javascript' => :json,
+      'application/x-www-form-urlencoded' => :query,
+      'text/plain' => :text
+    }
+
+    # The parsed response body.
+    #   Will attempt to parse application/x-www-form-urlencoded and
+    #   application/json Content-Type response bodies
+    def parsed
+      return nil unless PARSERS.key?(parser)
+      @parsed ||= PARSERS[parser].call(body)
+    end
+
+    # Attempts to determine the content type of the response.
+    def content_type
+      ((response.headers.values_at('content-type', 'Content-Type').compact.first || '').split(';').first || '').strip
+    end
+
+    # Determines the parser that will be used to supply the content of #parsed
+    def parser
+      return options[:parse].to_sym if PARSERS.key?(options[:parse])
+      CONTENT_TYPES[content_type]
+    end
+  end
+end
+
+begin
+  require 'multi_xml'
+  MpWeixin::Response.register_parser(:xml, ['text/xml', 'application/rss+xml', 'application/rdf+xml', 'application/atom+xml']) do |body|
+    MultiXml.parse(body) rescue body
+  end
+rescue LoadError; end