wechat-test 0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0550b9633270bc3cdd6d20e28c8cc543348c1618
+  data.tar.gz: 9b1095f0759ee293d7a88d6321e69ccfa0d075dd
+SHA512:
+  metadata.gz: 233d513958afed9c3842e9c2c1d0b339386e865f31461a2e9b1a5491f3448a301fbf8ac65f93f092e273e720e1cd98b5d089ed114d3bc6844faed734e7c30c58
+  data.tar.gz: 1e5e8d16b924c97d364d7dff1faa210f9203583b3066a66efdc98e144954c2c6d7fce2c0673a6e5d4d120a4cfbfc5ade69ade164d99e9e76dde35b643a6086fa

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 skinnyworm
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,307 @@
+Wechat Rails
+======================
+
+[![Build Status](https://travis-ci.org/skinnyworm/omniauth-wechat-oauth2.svg)](https://travis-ci.org/skinnyworm/wechat-rails) [![Code Climate](https://codeclimate.com/github/skinnyworm/wechat-rails.png)](https://codeclimate.com/github/skinnyworm/wechat-rails) [![Code Coverage](https://codeclimate.com/github/skinnyworm/wechat-rails/coverage.png)](https://codeclimate.com/github/skinnyworm/wechat-rails) [![Gem Version](https://badge.fury.io/rb/wechat-rails.png)](http://badge.fury.io/rb/wechat-rails)
+
+
+Wechat-rails 可以帮助开发者方便地在Rails环境中集成微信公众平台提供的所有服务，目前微信公众平台提供了以下几种类型的服务。
+
+- ##### 微信公众平台基本API, 无需Web环境。
+- ##### 消息处理机制, 需运行在Web环境中。
+- ##### OAuth 2.0认证机制
+
+Wechat-rails gem 包含了一个命令行程序可以调用各种无需web环境的API。同时它也提供了Rails Controller的responder DSL, 可以帮助开发者方便地在Rails应用中集成微信的消息处理机制。如果你的App还需要集成微信OAuth2.0, 你可以考虑[omniauth-wechat-oauth2](https://github.com/skinnyworm/omniauth-wechat-oauth2), 这个gem可以方便地和devise集成提供完整的用户认证.
+
+在使用这个Gem前，你需要获得微信API的appid, secret, token。具体情况可以参见http://mp.weixin.qq.com
+
+## 安装
+
+Using `gem install` or add to your app's `Gemfile`:
+
+```
+gem install "wechat-rails"
+```
+
+```
+gem "wechat-rails", git:"https://github.com/skinnyworm/wechat-rails"
+```
+
+
+## 配置
+
+#### 命令行程序的配置
+
+要使用命令行程序，你需要在你的home目录中创建一个`~/.wechat.yml`，包含以下内容。其中`access_token`是存放access_token的文件位置。
+
+```
+appid: "my_appid"
+secret: "my_secret"
+access_token: "/var/tmp/wechat_access_token"
+```
+
+#### Rails 全局配置
+Rails环境中, 你可以在config中创建wechat.yml, 为每个rails environment创建不同的配置。
+
+```
+default: &default
+  appid: "app_id"
+  secret: "app_secret"
+  token:  "app_token"
+  access_token: "/var/tmp/wechat_access_token"
+
+production: 
+  appid: <%= ENV['WECHAT_APPID'] %>
+  secret: <%= ENV['WECHAT_APP_SECRET'] %>
+  token:   <%= ENV['WECHAT_TOKEN'] %>
+  access_token:  <%= ENV['WECHAT_ACCESS_TOKEN'] %>
+
+staging: 
+  <<: *default
+
+development: 
+  <<: *default
+
+test: 
+  <<: *default
+```
+
+#### Rails 为每个Responder配置不同的appid和secret
+在个别情况下，你的app可能需要处理来自多个公众账号的消息，这时你可以配置多个responder controller。
+
+```ruby
+class WechatFirstController < ApplicationController
+   wechat_responder appid: "app1", secret: "secret1", token: "token1", access_token: Rails.root.join("tmp/access_token1")
+   
+   on :text, with:"help", respond: "help content"
+end
+```
+    
+## 使用命令行
+
+```
+$ wechat
+Wechat commands:
+  wechat custom_image [OPENID, IMAGE_PATH]                 # 发送图片客服消息
+  wechat custom_music [OPENID, THUMBNAIL_PATH, MUSIC_URL]  # 发送音乐客服消息
+  wechat custom_news [OPENID, NEWS_YAML_FILE]              # 发送图文客服消息
+  wechat custom_text [OPENID, TEXT_MESSAGE]                # 发送文字客服消息
+  wechat custom_video [OPENID, VIDEO_PATH]                 # 发送视频客服消息
+  wechat custom_voice [OPENID, VOICE_PATH]                 # 发送语音客服消息
+  wechat template_message [OPENID, TEMPLATE_YAML_FILE]     # 发送模板消息
+  wechat help [COMMAND]                                    # Describe available commands or one specific command
+  wechat media [MEDIA_ID, PATH]                            # 媒体下载
+  wechat media_create [MEDIA_ID, PATH]                     # 媒体上传
+  wechat menu                                              # 当前菜单
+  wechat menu_create [MENU_YAML]                           # 创建菜单
+  wechat menu_delete                                       # 删除菜单
+  wechat user [OPEN_ID]                                    # 查找关注者
+  wechat users                                             # 关注者列表
+
+```
+
+### 使用场景
+以下是几种典型场景的使用方法
+
+#####获取所有用户的OPENID
+
+```
+$ wechat users
+
+{"total"=>4, "count"=>4, "data"=>{"openid"=>["oCfEht9***********", "oCfEhtwqa***********", "oCfEht9oMCqGo***********", "oCfEht_81H5o2***********"]}, "next_openid"=>"oCfEht_81H5o2***********"}
+
+```
+
+#####获取用户的信息
+
+```
+$ wechat user "oCfEht9***********"
+
+{"subscribe"=>1, "openid"=>"oCfEht9***********", "nickname"=>"Nickname", "sex"=>1, "language"=>"zh_CN", "city"=>"徐汇", "province"=>"上海", "country"=>"中国", "headimgurl"=>"http://wx.qlogo.cn/mmopen/ajNVdqHZLLBd0SG8NjV3UpXZuiaGGPDcaKHebTKiaTyof*********/0", "subscribe_time"=>1395715239}
+
+```
+
+#####获取用户的信息
+
+```
+$ wechat user "oCfEht9***********"
+
+{"subscribe"=>1, "openid"=>"oCfEht9***********", "nickname"=>"Nickname", "sex"=>1, "language"=>"zh_CN", "city"=>"徐汇", "province"=>"上海", "country"=>"中国", "headimgurl"=>"http://wx.qlogo.cn/mmopen/ajNVdqHZLLBd0SG8NjV3UpXZuiaGGPDcaKHebTKiaTyof*********/0", "subscribe_time"=>1395715239}
+```
+
+##### 获取当前菜单
+```
+$ wechat menu
+
+{"menu"=>{"button"=>[{"type"=>"view", "name"=>"保护的", "url"=>"http://***/protected", "sub_button"=>[]}, {"type"=>"view", "name"=>"公开的", "url"=>"http://***", "sub_button"=>[]}]}}
+
+```
+
+##### 创建菜单
+创建菜单需要一个定义菜单内容的yaml文件，比如
+menu.yaml
+
+```
+button:
+  -
+    type: "view"
+    name: "保护的"
+    url: "http://***/protected"
+  -
+    type: "view"
+    name: "公开的"
+    url: "http://***"
+    
+```
+
+然后执行命令行
+
+```
+$ wechat menu_create menu.yaml
+
+```
+
+##### 发送客服图文消息
+需定义一个图文消息内容的yaml文件，比如
+articles.yaml
+
+```
+articles:
+ -
+  title: "习近平在布鲁日欧洲学院演讲"
+  description: "新华网比利时布鲁日4月1日电 国家主席习近平1日在比利时布鲁日欧洲学院发表重要演讲"
+  url: "http://news.sina.com.cn/c/2014-04-01/232629843387.shtml"
+  pic_url: "http://i3.sinaimg.cn/dy/c/2014-04-01/1396366518_bYays1.jpg"
+```
+
+然后执行命令行
+
+```
+$ wechat custom_news oCfEht9oM*********** articles.yml 
+
+```
+
+##### 发送模板消息
+需定义一个模板消息内容的yaml文件，比如
+template.yml
+
+```
+template:
+  template_id: "o64KQ62_xxxxxxxxxxxxxxx-Qz-MlNcRKteq8"
+  url: "http://weixin.qq.com/download"
+  topcolor: "#FF0000"
+  data:
+    first: 
+      value: "你好，你已报名成功"
+      color: "#0A0A0A"      
+    keynote1:
+      value: "XX活动"
+      color: "#CCCCCC"      
+    keynote2:
+      value: "2014年9月16日"
+      color: "#CCCCCC"     
+    keynote3:
+      value: "上海徐家汇xxx城"
+      color: "#CCCCCC"                 
+    remark:
+      value: "欢迎再次使用。"
+      color: "#173177"          
+
+```
+
+然后执行命令行
+
+```
+$ wechat template_message oCfEht9oM*********** template.yml
+
+```
+
+## Rails Responder Controller DSL
+
+为了在Rails app中响应用户的消息，开发者需要创建一个wechat responder controller. 首先在router中定义
+
+```ruby
+  resource :wechat, only:[:show, :create]
+
+```
+
+然后创建Controller class, 例如
+
+```ruby
+
+class WechatsController < ApplicationController
+  wechat_responder
+  
+  # 默认的文字信息responder
+  on :text do |request, content|
+    request.reply.text "echo: #{content}" #Just echo
+  end
+
+  # 当请求的文字信息内容为'help'时, 使用这个responder处理
+  on :text, with:"help" do |request, help|
+    request.reply.text "help content" #回复帮助信息
+  end
+
+  # 当请求的文字信息内容为'<n>条新闻'时, 使用这个responder处理, 并将n作为第二个参数
+  on :text, with: /^(\d+)条新闻$/ do |request, count|
+    articles_range = (0... [count.to_i, 10].min)
+    request.reply.news(articles_range) do |article, i| #回复"articles"
+      article.item title: "标题#{i}", description:"内容描述#{i}", pic_url: "http://www.baidu.com/img/bdlogo.gif", url:"http://www.baidu.com/"
+    end
+  end
+
+  # 处理图片信息
+  on :image do |request|
+    request.reply.image(request[:MediaId]) #直接将图片返回给用户
+  end
+
+  # 处理语音信息
+  on :voice do |request|
+    request.reply.voice(request[:MediaId]) #直接语音音返回给用户
+  end
+
+  # 处理视频信息
+  on :video do |request|
+    nickname = wechat.user(request[:FromUserName])["nickname"] #调用 api 获得发送者的nickname
+    request.reply.video(request[:MediaId], title: "回声", description: "#{nickname}发来的视频请求") #直接视频返回给用户
+  end
+
+  # 处理地理位置信息
+  on :location do |request|
+    request.reply.text("#{request[:Location_X]}, #{request[:Location_Y]}") #回复地理位置
+  end
+
+  # 当无任何responder处理用户信息时,使用这个responder处理
+  on :fallback, respond: "fallback message"  
+end
+
+```
+
+在controller中使用`wechat_responder`引入Responder DSL, 之后可以用
+
+```
+on <message_type> do |message|
+ message.reply.text "some text"
+end
+
+```
+来响应用户信息。
+
+目前支持的message_type有如下几种
+
+- :text 响应文字消息,可以用`:with`参数来匹配文本内容 `on(:text, with:'help'){|message, content| ...}`
+- :image 响应图片消息
+- :voice 响应语音消息
+- :video 响应视频消息
+- :location 响应地理位置消息
+- :link 响应链接消息
+- :event 响应事件消息, 可以用`:with`参数来匹配事件类型
+- :fallback 默认响应，当收到的消息无法被其他responder响应时，会使用这个responder.
+
+## Message DSL
+
+Wechat-rails 的核心是一个Message DSL,帮助开发者构建各种类型的消息，包括主动推送的和被动响应的。
+....
+
+  
+
+

data/Rakefile

@@ -0,0 +1,29 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'WechatRails'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+require File.join('bundler', 'gem_tasks')
+require File.join('rspec', 'core', 'rake_task')
+RSpec::Core::RakeTask.new(:spec)
+
+
+task :default => :spec

data/bin/wechat

@@ -0,0 +1,144 @@
+#!/usr/bin/env ruby
+
+lib = File.expand_path(File.dirname(__FILE__) + '/../lib')
+$LOAD_PATH.unshift(lib) if File.directory?(lib) && !$LOAD_PATH.include?(lib)
+
+require 'thor'
+require "wechat-rails"
+require 'json'  
+require "active_support/core_ext"
+require 'fileutils'
+require 'yaml'
+
+
+class App < Thor                                                 
+  class Helper
+    def self.with(options)
+      config_file = File.join(Dir.home, ".wechat.yml")
+      config = YAML.load(File.new(config_file).read) if File.exist?(config_file)
+
+      config ||= {}
+      appid =  config["appid"]
+      secret = config["secret"]
+      token_file = options[:toke_file] ||  config["access_token"] || "/var/tmp/wechat_access_token"
+
+      if (appid.nil? || secret.nil? || token_file.nil?)
+      puts <<-HELP
+You need create ~/.wechat.yml with wechat appid and secret. For example:
+
+  appid: <wechat appid>
+  secret: <wechat secret>
+  access_toke: "/var/tmp/wechat_access_token"
+
+HELP
+      exit 1
+      end
+      Wechat::Api.new(appid, secret, token_file)
+    end
+  end
+
+  package_name "Wechat"
+  option :toke_file, :aliases=>"-t", :desc => "File to store access token"
+
+  desc "users", "关注者列表"
+  def users
+    puts Helper.with(options).users
+  end
+
+  desc "user [OPEN_ID]", "查找关注者"
+  def user(open_id)
+    puts Helper.with(options).user(open_id)
+  end
+
+  desc "menu", "当前菜单"
+  def menu
+    puts Helper.with(options).menu
+  end
+
+  desc "menu_delete", "删除菜单"
+  def menu_delete
+    puts "Menu deleted" if Helper.with(options).menu_delete
+  end
+
+  desc "menu_create [MENU_YAML]", "创建菜单"
+  def menu_create(menu_yaml)
+    menu = YAML.load(File.new(menu_yaml).read)
+    puts "Menu created" if Helper.with(options).menu_create(menu)
+  end
+
+  desc "media [MEDIA_ID, PATH]", "媒体下载"
+  def media(media_id, path)
+    tmp_file = Helper.with(options).media(media_id)
+    FileUtils.mv(tmp_file.path, path)
+    puts "File downloaded"
+  end
+
+  desc "media_create [MEDIA_ID, PATH]", "媒体上传"
+  def media_create(type, path)
+    file = File.new(path)
+    puts Helper.with(options).media_create(type, file)
+  end
+  
+  desc "custom_text [OPENID, TEXT_MESSAGE]", "发送文字客服消息"
+  def custom_text openid, text_message
+    puts Helper.with(options).custom_message_send Wechat::Message.to(openid).text(text_message)
+  end
+
+  desc "custom_image [OPENID, IMAGE_PATH]", "发送图片客服消息"
+  def custom_image openid, image_path
+    file = File.new(image_path)
+    api = Helper.with(options)
+
+    media_id = api.media_create("image", file)["media_id"]
+    puts api.custom_message_send Wechat::Message.to(openid).image(media_id)
+  end
+
+  desc "custom_voice [OPENID, VOICE_PATH]", "发送语音客服消息"
+  def custom_voice openid, voice_path
+    file = File.new(voice_path)
+    api = Helper.with(options)
+
+    media_id = api.media_create("voice", file)["media_id"]
+    puts api.custom_message_send Wechat::Message.to(openid).voice(media_id)
+  end
+
+  desc "custom_video [OPENID, VIDEO_PATH]", "发送视频客服消息"
+  method_option :title, :aliases => "-h", :desc => "视频标题"
+  method_option :description, :aliases => "-d", :desc => "视频描述"
+  def custom_video openid, video_path
+    file = File.new(video_path)
+    api = Helper.with(options)
+
+    api_opts = options.slice(:title, :description)
+    media_id = api.media_create("video", file)["media_id"]
+    puts api.custom_message_send Wechat::Message.to(openid).video(media_id, api_opts)
+  end
+
+  desc "custom_music [OPENID, THUMBNAIL_PATH, MUSIC_URL]", "发送音乐客服消息"
+  method_option :title, :aliases => "-h", :desc => "音乐标题"
+  method_option :description, :aliases => "-d", :desc => "音乐描述"
+  method_option :HQ_music_url, :aliases => "-u", :desc => "高质量音乐URL链接"
+  def custom_music openid, thumbnail_path, music_url
+    file = File.new(thumbnail_path)
+    api = Helper.with(options)
+
+    api_opts = options.slice(:title, :description, :HQ_music_url)
+    thumb_media_id = api.media_create("thumb", file)["thumb_media_id"]
+    puts api.custom_message_send Wechat::Message.to(openid).music(thumb_media_id, music_url, api_opts)
+  end
+
+  desc "custom_news [OPENID, NEWS_YAML_FILE]", "发送图文客服消息"
+  def custom_news openid, news_yaml
+    articles = YAML.load(File.new(news_yaml).read)
+    puts Helper.with(options).custom_message_send Wechat::Message.to(openid).news(articles["articles"])
+  end
+
+  desc "template_message [OPENID, TEMPLATE_YAML_FILE]", "模板消息接口"
+  def template_message openid, template_yaml
+    template = YAML.load(File.new(template_yaml).read)
+    puts Helper.with(options).template_message_send Wechat::Message.to(openid).template(template["template"])    
+  end
+
+end
+
+App.start

data/lib/wechat-rails.rb

@@ -0,0 +1,51 @@
+require "wechat/api"
+
+module Wechat
+  autoload :Message, "wechat/message"
+  autoload :Responder, "wechat/responder"
+  autoload :Response, "wechat/response"
+
+  class AccessTokenExpiredError < StandardError; end
+  class ResponseError < StandardError
+    attr_reader :error_code
+    def initialize(errcode, errmsg)
+      error_code = errcode
+      super "#{errmsg}(#{error_code})"
+    end
+  end
+
+  attr_reader :config
+
+  def self.config
+    @config ||= begin
+      if defined? Rails
+        config_file = Rails.root.join("config/wechat.yml")
+        config = YAML.load(ERB.new(File.new(config_file).read).result)[Rails.env] if (File.exist?(config_file))
+      end
+
+      config ||= {appid: ENV["WECHAT_APPID"], secret: ENV["WECHAT_SECRET"], token: ENV["WECHAT_TOKEN"], access_token: ENV["WECHAT_ACCESS_TOKEN"]}
+      config.symbolize_keys!
+      config[:access_token] ||= Rails.root.join("tmp/access_token").to_s
+      OpenStruct.new(config)
+    end
+  end
+
+  def self.api
+    @api ||= Wechat::Api.new(self.config.appid, self.config.secret, self.config.access_token)
+  end
+end
+
+if defined? ActionController::Base
+  class ActionController::Base
+    def self.wechat_responder opts={}
+      self.send(:include, Wechat::Responder)
+      if (opts.empty?)
+        self.wechat = Wechat.api
+        self.token = Wechat.config.token
+      else
+        self.wechat = Wechat::Api.new(opts[:appid], opts[:secret], opts[:access_token])
+        self.token = opts[:token]
+      end
+    end
+  end
+end

data/lib/wechat.rb

@@ -0,0 +1,128 @@
+
+require 'thor'
+require 'json'  
+require "active_support/core_ext"
+require 'fileutils'
+
+require_relative "wechat-rails"
+
+
+class App < Thor                                                 
+  class Helper
+    def self.with(options)
+      appid =  Wechat.config.appid
+      secret = Wechat.config.secret
+      token_file = options[:toke_file] || Wechat.config.access_token
+
+      if (appid.nil? || secret.nil? || token_file.nil?)
+      puts <<-HELP
+You need create ~/.wechat.yml with wechat appid and secret. For example:
+
+  appid: <wechat appid>
+  secret: <wechat secret>
+  access_toke: "/var/tmp/wechat_access_token"
+
+HELP
+      exit 1
+      end
+      Wechat::Api.new(appid, secret, token_file)
+    end
+  end
+
+  package_name "Wechat"
+  option :toke_file, :aliases=>"-t", :desc => "File to store access token"
+
+  desc "users", "关注者列表"
+  def users
+    puts Helper.with(options).users
+  end
+
+  desc "user [OPEN_ID]", "查找关注者"
+  def user(open_id)
+    puts Helper.with(options).user(open_id)
+  end
+
+  desc "menu", "当前菜单"
+  def menu
+    puts Helper.with(options).menu
+  end
+
+  desc "menu_delete", "删除菜单"
+  def menu_delete
+    puts "Menu deleted" if Helper.with(options).menu_delete
+  end
+
+  desc "menu_create [MENU_YAML]", "创建菜单"
+  def menu_create(menu_yaml)
+    menu = YAML.load(File.new(menu_yaml).read)
+    puts "Menu created" if Helper.with(options).menu_create(menu)
+  end
+
+  desc "media [MEDIA_ID, PATH]", "媒体下载"
+  def media(media_id, path)
+    tmp_file = Helper.with(options).media(media_id)
+    FileUtils.mv(tmp_file.path, path)
+    puts "File downloaded"
+  end
+
+  desc "media_create [MEDIA_ID, PATH]", "媒体上传"
+  def media_create(type, path)
+    file = File.new(path)
+    puts Helper.with(options).media_create(type, file)
+  end
+  
+  desc "custom_text [OPENID, TEXT_MESSAGE]", "发送文字客服消息"
+  def custom_text openid, text_message
+    puts Helper.with(options).custom_message_send Wechat::Message.to(openid).text(text_message)
+  end
+
+  desc "custom_image [OPENID, IMAGE_PATH]", "发送图片客服消息"
+  def custom_image openid, image_path
+    file = File.new(image_path)
+    api = Helper.with(options)
+
+    media_id = api.media_create("image", file)["media_id"]
+    puts api.custom_message_send Wechat::Message.to(openid).image(media_id)
+  end
+
+  desc "custom_voice [OPENID, VOICE_PATH]", "发送语音客服消息"
+  def custom_voice openid, voice_path
+    file = File.new(voice_path)
+    api = Helper.with(options)
+
+    media_id = api.media_create("voice", file)["media_id"]
+    puts api.custom_message_send Wechat::Message.to(openid).voice(media_id)
+  end
+
+  desc "custom_video [OPENID, VIDEO_PATH]", "发送视频客服消息"
+  method_option :title, :aliases => "-h", :desc => "视频标题"
+  method_option :description, :aliases => "-d", :desc => "视频描述"
+  def custom_video openid, video_path
+    file = File.new(video_path)
+    api = Helper.with(options)
+
+    api_opts = options.slice(:title, :description)
+    media_id = api.media_create("video", file)["media_id"]
+    puts api.custom_message_send Wechat::Message.to(openid).video(media_id, api_opts)
+  end
+
+  desc "custom_music [OPENID, THUMBNAIL_PATH, MUSIC_URL]", "发送音乐客服消息"
+  method_option :title, :aliases => "-h", :desc => "音乐标题"
+  method_option :description, :aliases => "-d", :desc => "音乐描述"
+  method_option :HQ_music_url, :aliases => "-u", :desc => "高质量音乐URL链接"
+  def custom_music openid, thumbnail_path, music_url
+    file = File.new(thumbnail_path)
+    api = Helper.with(options)
+
+    api_opts = options.slice(:title, :description, :HQ_music_url)
+    thumb_media_id = api.media_create("thumb", file)["thumb_media_id"]
+    puts api.custom_message_send Wechat::Message.to(openid).music(thumb_media_id, music_url, api_opts)
+  end
+
+  desc "custom_news [OPENID, NEWS_YAML_FILE]", "发送图文客服消息"
+  def custom_news openid, news_yaml
+    articles = YAML.load(File.new(news_yaml).read)
+    puts Helper.with(options).custom_message_send Wechat::Message.to(openid).news(articles["articles"])
+  end
+
+end

data/lib/wechat/access_token.rb

@@ -0,0 +1,35 @@
+module Wechat
+  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 Wechat::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 = Wechat::Client.new(API_BASE)
+    @access_token = Wechat::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 Wechat::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 Wechat
+  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 Wechat
+  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
+        Wechat.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,110 @@
+module Wechat
+  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, :fallback]
+        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
+
+    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

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: wechat-test
+version: !ruby/object:Gem::Version
+  version: '0.0'
+platform: ruby
+authors:
+- Skinnyworm
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: API and message handling for wechat in rails environment
+email: askinnyworm@gmail.com
+executables:
+- wechat
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- Rakefile
+- bin/wechat
+- lib/wechat-rails.rb
+- lib/wechat.rb
+- lib/wechat/access_token.rb
+- lib/wechat/api.rb
+- lib/wechat/client.rb
+- lib/wechat/message.rb
+- lib/wechat/responder.rb
+homepage: https://github.com/skinnyworm/wechat-rails
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: DSL for wechat message handling and api
+test_files: []