wechat_public 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4568f46e962b94efd05b7410166f2d44cbc205ac
-  data.tar.gz: 256927033a0075ad1ee68a0d0d0b18dfa2ac6cb5
+  metadata.gz: 744beadd7a9d6788a4ba9c10749824fd3f075fd2
+  data.tar.gz: 9185439b87d650df02b85728b84614ad070a0196
 SHA512:
-  metadata.gz: 0c041608b86c40fdad5386d665c8a748fe4849ea610290b795b7b01a1c8338f102a34ee8ad2f15cd819ee407decb0c162589a78785246827992d5bfd6ab58b40
-  data.tar.gz: a9f58047e3f916176ff7ea982eca9689b27675465e1289de6b1e150f1c931a2cc2bb2c5341232e965eda3d13ddc64f816f673317df8b0286f01cbc26ffac3da7
+  metadata.gz: d2b1b1d158d4b177363c2036de94987fe9d83851ae9ad7f08ac85a31ff38e1cc15cd83ae29c92707f3b234f252c1c5af73d7eb78ad2b4080fd3a824717fc3a5b
+  data.tar.gz: 7dbcff4a3af30a9ff00689db86fdabf3f5542a50e4f348fff1df285fb267912e798c5b9e63750252fb9b672c111739b2ceb91756a38beb3cad055df16cf39798

data/lib/wechat/access_token.rb

@@ -0,0 +1,35 @@
+module WechatPublic
+  class AccessToken
+    attr_reader :client, :appid, :secret, :token_file, :token_data
+
+    def initialize(client, appid, secret, token_file)
+      @appid = appid
+      @secret = secret
+      @client = client
+      @token_file = token_file
+    end
+
+    def token
+      begin
+        @token_data ||= JSON.parse(File.read(token_file))
+      rescue
+        self.refresh
+      end
+      return valid_token(@token_data)
+    end
+
+    def refresh
+      data = client.get("token", params:{grant_type: "client_credential", appid: appid, secret: secret})
+      File.open(token_file, 'w'){|f| f.write(data.to_s)} if valid_token(data)
+      return @token_data = data
+    end
+
+    private 
+    def valid_token token_data
+      access_token = token_data["access_token"]
+      raise "Response didn't have access_token" if  access_token.blank?
+      return access_token
+    end
+
+  end
+end

data/lib/wechat/api.rb

@@ -0,0 +1,72 @@
+require 'wechat/client'
+require 'wechat/access_token'
+
+class WechatPublic::Api
+  attr_reader :access_token, :client
+
+  API_BASE = "https://api.weixin.qq.com/cgi-bin/"
+  FILE_BASE = "http://file.api.weixin.qq.com/cgi-bin/"
+
+  def initialize appid, secret, token_file
+    @client = WechatPublic::Client.new(API_BASE)
+    @access_token = WechatPublic::AccessToken.new(@client, appid, secret, token_file)
+  end
+
+  def users nextid = nil
+    params = {params: {next_openid: nextid}} if nextid.present?
+    get('user/get', params||{})
+  end
+
+  def user openid
+    get("user/info", params:{openid: openid})
+  end
+
+  def menu
+    get("menu/get")
+  end
+
+  def menu_delete
+    get("menu/delete")
+  end
+
+  def menu_create menu
+    # 微信不接受7bit escaped json(eg \uxxxx), 中文必须UTF-8编码, 这可能是个安全漏洞
+    post("menu/create", JSON.generate(menu))
+  end
+
+  def media media_id
+    response = get "media/get", params:{media_id: media_id}, base: FILE_BASE, as: :file
+  end
+
+  def media_create type, file
+    post "media/upload", {upload:{media: file}}, params:{type: type}, base: FILE_BASE
+  end
+
+  def custom_message_send message
+    post "message/custom/send", message.to_json, content_type: :json
+  end
+  
+  def template_message_send message
+    post "message/template/send", message.to_json, content_type: :json
+  end  
+
+  protected
+  def get path, headers={}
+    with_access_token(headers[:params]){|params| client.get path, headers.merge(params: params)}
+  end
+
+  def post path, payload, headers = {}
+    with_access_token(headers[:params]){|params| client.post path, payload, headers.merge(params: params)}
+  end
+
+  def with_access_token params={}, tries=2
+    begin
+      params ||= {}
+      yield(params.merge(access_token: access_token.token))
+    rescue WechatPublic::AccessTokenExpiredError => ex
+      access_token.refresh
+      retry unless (tries -= 1).zero?
+    end 
+  end
+
+end

data/lib/wechat/client.rb

@@ -0,0 +1,74 @@
+require 'rest_client'
+
+module WechatPublic
+  class Client
+
+    attr_reader :base
+
+    def initialize(base)
+      @base = base
+    end
+
+    def get path, header={}
+      request(path, header) do |url, header|
+        RestClient.get(url, header)
+      end
+    end
+
+    def post path, payload, header = {}
+      request(path, header) do |url, header|
+        RestClient.post(url, payload, header)
+      end
+    end
+
+    def request path, header={}, &block
+      url = "#{header.delete(:base) || self.base}#{path}"
+      as = header.delete(:as)
+      header.merge!(:accept => :json)
+      response = yield(url, header)
+
+      raise "Request not OK, response code #{response.code}" if response.code != 200
+      parse_response(response, as || :json) do |parse_as, data|
+        break data unless (parse_as == :json && data["errcode"].present?)
+
+        case data["errcode"]
+        when 0 # for request didn't expect results
+          true
+
+        when 42001, 40014 #42001: access_token超时, 40014:不合法的access_token
+          raise AccessTokenExpiredError
+          
+        else
+          raise ResponseError.new(data['errcode'], data['errmsg'])
+        end
+      end
+    end
+
+    private
+    def parse_response response, as
+      content_type = response.headers[:content_type] 
+      parse_as = {
+        /^application\/json/ => :json,
+        /^image\/.*/ => :file
+      }.inject([]){|memo, match| memo<<match[1] if content_type =~ match[0]; memo}.first || as || :text
+
+      case parse_as
+      when :file
+        file = Tempfile.new("tmp")
+        file.binmode
+        file.write(response.body)
+        file.close
+        data = file
+
+      when :json
+        data = JSON.parse(response.body.gsub /[\u0000-\u001f]+/, '')
+
+      else
+        data = response.body
+      end
+
+      return yield(parse_as, data)
+    end
+
+  end
+end

data/lib/wechat/message.rb

@@ -0,0 +1,171 @@
+module WechatPublic
+  class Message
+
+    JSON_KEY_MAP = {
+      "ToUserName" => "touser",
+      "MediaId" => "media_id",
+      "ThumbMediaId" => "thumb_media_id",
+      "TemplateId"=>"template_id"
+    }
+
+    class << self
+      def from_hash message_hash
+        self.new(message_hash)
+      end
+
+      def to to_user
+        self.new(:ToUserName=>to_user, :CreateTime=>Time.now.to_i)
+      end
+    end
+
+    class ArticleBuilder
+      attr_reader :items
+      delegate :count, to: :items
+      def initialize 
+        @items=Array.new
+      end
+
+      def item title: "title", description: nil, pic_url: nil, url: nil
+        items << {:Title=> title, :Description=> description, :PicUrl=> pic_url, :Url=> url}.reject{|k,v| v.nil? }
+      end
+    end
+
+    attr_reader :message_hash
+
+    def initialize(message_hash)
+      @message_hash = message_hash || {}
+    end
+
+    def [](key)
+      message_hash[key]
+    end
+
+    def reply
+      Message.new(
+        :ToUserName=>message_hash[:FromUserName], 
+        :FromUserName=>message_hash[:ToUserName], 
+        :CreateTime=>Time.now.to_i
+      )
+    end
+
+    def as type
+      case type
+      when :text
+        message_hash[:Content]
+
+      when :image, :voice, :video
+        WechatPublic.api.media(message_hash[:MediaId])
+
+      when :location
+        message_hash.slice(:Location_X, :Location_Y, :Scale, :Label).inject({}){|results, value| 
+          results[value[0].to_s.underscore.to_sym] = value[1]; results}
+      else
+        raise "Don't know how to parse message as #{type}"
+      end
+    end
+
+    def to openid
+      update(:ToUserName=>openid)
+    end
+
+    def text content
+      update(:MsgType=>"text", :Content=>content)
+    end
+
+    def image media_id
+      update(:MsgType=>"image", :Image=>{:MediaId=>media_id})
+    end
+
+    def voice media_id
+      update(:MsgType=>"voice", :Voice=>{:MediaId=>media_id})
+    end
+
+    def video media_id, opts={}
+      video_fields = camelize_hash_keys({media_id: media_id}.merge(opts.slice(:title, :description)))
+      update(:MsgType=>"video", :Video=>video_fields)
+    end
+
+    def music thumb_media_id, music_url, opts={}
+      music_fields = camelize_hash_keys(opts.slice(:title, :description, :HQ_music_url).merge(music_url: music_url, thumb_media_id: thumb_media_id))
+      update(:MsgType=>"music", :Music=>music_fields)
+    end
+
+    def news collection, &block
+      if block_given?
+        article = ArticleBuilder.new
+        collection.each{|item| yield(article, item)}
+        items = article.items
+      else
+        items = collection.collect do |item| 
+         camelize_hash_keys(item.symbolize_keys.slice(:title, :description, :pic_url, :url).reject{|k,v| v.nil? })
+        end
+      end
+
+      update(:MsgType=>"news", :ArticleCount=> items.count, 
+        :Articles=> items.collect{|item| camelize_hash_keys(item)})
+    end
+
+    def template opts={}
+      template_fields = camelize_hash_keys(opts.symbolize_keys.slice(:template_id, :topcolor, :url, :data))
+      update(:MsgType=>"template",:Template=> template_fields)
+    end
+
+    def to_xml
+      message_hash.to_xml(root: "xml", children: "item", skip_instruct: true, skip_types: true)
+    end
+
+    def to_json
+      json_hash = deep_recursive(message_hash) do |key, value|
+        key = key.to_s
+        [(JSON_KEY_MAP[key] || key.downcase), value]
+      end
+
+      json_hash.slice!("touser", "msgtype", "content", "image", "voice", "video", "music", "news", "articles","template").to_hash
+      case json_hash["msgtype"]
+      when "text"
+        json_hash["text"] = {"content" => json_hash.delete("content")}
+      when "news"
+        json_hash["news"] = {"articles" => json_hash.delete("articles")}
+      when "template"
+        json_hash.merge! json_hash['template']
+      end
+      JSON.generate(json_hash)
+    end
+
+    def save_to! model_class
+      model = model_class.new(underscore_hash_keys(message_hash))
+      model.save!
+      return self
+    end
+
+    private
+    def camelize_hash_keys hash
+      deep_recursive(hash){|key, value| [key.to_s.camelize.to_sym, value]} 
+    end
+
+    def underscore_hash_keys hash
+      deep_recursive(hash){|key, value| [key.to_s.underscore.to_sym, value]} 
+    end
+
+    def update fields={}
+      message_hash.merge!(fields)
+      return self
+    end
+
+    def deep_recursive hash, &block
+      hash.inject({}) do |memo, val|
+        key,value = *val
+        case value.class.name
+        when "Hash"
+          value = deep_recursive(value, &block)
+        when "Array"
+          value = value.collect{|item| item.is_a?(Hash) ? deep_recursive(item, &block) : item}
+        end
+
+        key,value = yield(key, value)
+        memo.merge!(key => value)
+      end
+    end
+
+  end
+end

data/lib/wechat/responder.rb

@@ -0,0 +1,124 @@
+module WechatPublic
+  module Responder
+    extend ActiveSupport::Concern
+
+    included do 
+      self.skip_before_filter :verify_authenticity_token
+      self.before_filter :verify_signature, only: [:show, :create]
+      #delegate :wehcat, to: :class
+    end
+
+    module ClassMethods
+
+      attr_accessor :wechat, :token
+
+      def on message_type, with: nil, respond: nil, &block
+        raise "Unknow message type" unless message_type.in? [:text, :image, :voice, :video, :location, :link, :event, :login]
+        config=respond.nil? ? {} : {:respond=>respond}
+        config.merge!(:proc=>block) if block_given?
+
+        if (with.present? && !message_type.in?([:text, :event]))
+          raise "Only text and event message can take :with parameters"
+        else
+          config.merge!(:with=>with) if with.present?
+        end
+
+        responders(message_type) << config
+        return config
+      end
+
+      def responders type
+        @responders ||= Hash.new
+        @responders[type] ||= Array.new
+      end
+
+      def responder_for message, &block
+        message_type = message[:MsgType].to_sym
+        responders = responders(message_type)      
+        case message_type
+        when :text
+          yield(* match_responders(responders, message[:Content]))
+
+        when :event
+          if message[:Event] == 'CLICK'
+            yield(* match_responders(responders, message[:EventKey]))
+          else
+            yield(* match_responders(responders, message[:Event]))
+          end
+        else
+          yield(responders.first)
+        end
+      end
+
+      private 
+
+      def match_responders responders, value
+        matched = responders.inject({scoped:nil, general:nil}) do |matched, responder|
+          condition = responder[:with]
+
+          if condition.nil?
+            matched[:general] ||= [responder, value]
+            next matched
+          end
+          
+          if condition.is_a? Regexp
+            matched[:scoped] ||= [responder] + $~.captures if(value =~ condition)
+          else
+            matched[:scoped] ||= [responder, value] if(value == condition)
+          end
+          matched
+        end
+        return matched[:scoped] || matched[:general] 
+      end
+    end
+
+    
+    # def show
+    #   render :text => params[:echostr]
+    # end
+
+    # def create
+    #   request = Wechat::Message.from_hash(params[:xml] || post_xml)
+    #   response = self.class.responder_for(request) do |responder, *args|
+    #     responder ||= self.class.responders(:fallback).first
+
+    #     next if responder.nil?
+    #     next request.reply.text responder[:respond] if (responder[:respond])
+    #     next responder[:proc].call(*args.unshift(request)) if (responder[:proc])
+    #   end
+
+    #   if response.respond_to? :to_xml
+    #     render xml: response.to_xml
+    #   else
+    #     render :nothing => true, :status => 200, :content_type => 'text/html'
+    #   end
+    # end
+    
+    def get_uid params
+      request = WechatPublic::Message.from_hash(params[:xml] || post_xml)
+      response = self.class.responder_for(request) do |responder, *args|
+        responder ||= self.class.responders(:login).first
+
+        next if responder.nil?
+        next request.reply.text responder[:respond] if (responder[:respond])
+        next responder[:proc].call(*args.unshift(request)) if (responder[:proc])
+      end
+      {
+        request: request,
+        response: response
+      }
+    end
+
+    private
+    def verify_signature
+      array = [self.class.token, params[:timestamp], params[:nonce]].compact.collect(&:to_s).sort
+      render :text => "Forbidden", :status => 403 if params[:signature] != Digest::SHA1.hexdigest(array.join)
+    end
+
+    private
+    def post_xml
+      data = Hash.from_xml(request.raw_post)
+      HashWithIndifferentAccess.new_from_hash_copying_default data.fetch('xml', {})
+    end
+  end
+end

data/lib/wechat/test.rb

@@ -0,0 +1,7 @@
+module WechatPublic
+  module Test
+    def self.print
+      puts "我加载成功了啊......"
+    end
+  end
+end

data/lib/wechat_public/test.rb

@@ -0,0 +1,7 @@
+module WechatPublic
+  module Test
+    def self.print
+      puts "我加载成功了啊......"
+    end
+  end
+end

data/lib/wechat_public/version.rb

@@ -1,3 +1,3 @@
 module WechatPublic
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

data/lib/wechat_public.rb

@@ -1,11 +1,11 @@
 require "wechat_public/version"
-require "wechat/test"
+require "wechat/api"
 module WechatPublic
   autoload :Message, "wechat/message"
   autoload :Responder, "wechat/responder"
   autoload :Response, "wechat/response"
- # autoload :Test, 'wechat/test'
-
+  autoload :Test, 'wechat/test'
+  #WechatPublic::Test.print
   class AccessTokenExpiredError < StandardError; end
   class ResponseError < StandardError
     attr_reader :error_code
@@ -31,7 +31,8 @@ module WechatPublic
       puts config
       OpenStruct.new(config)
       puts "判断 ActionController::Base...加载了么",ActionController::Base
-      #Test.print
+      puts "判断 WechatPublic::Test 。。加载了么",WechatPublic::Test
+      WechatPublic::Test.print
     end
   end
 

data/wechat_public.gemspec

@@ -2,6 +2,7 @@
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'wechat_public/version'
+require 'wechat_public/test'
 
 Gem::Specification.new do |spec|
   spec.name          = "wechat_public"
@@ -20,4 +21,8 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.6"
   spec.add_development_dependency 'rake', '~> 0'
+  # spec.add_development_dependency 'rest_client', '~> 1.8'
+  # spec.add_development_dependency 'rails', '~> 4.2'
+  spec.add_runtime_dependency 'rest_client', '>= 1.8'
+  spec.add_runtime_dependency 'rails', ">= 4.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wechat_public
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Will
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-18 00:00:00.000000000 Z
+date: 2015-04-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -38,6 +38,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rest_client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
 description: one coding programmer.
 email:
 - yh@fir.im
@@ -50,7 +78,14 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- lib/wechat/access_token.rb
+- lib/wechat/api.rb
+- lib/wechat/client.rb
+- lib/wechat/message.rb
+- lib/wechat/responder.rb
+- lib/wechat/test.rb
 - lib/wechat_public.rb
+- lib/wechat_public/test.rb
 - lib/wechat_public/version.rb
 - wechat_public.gemspec
 homepage: ''