weichat_rails 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: dbde8b2fd7ae43678424029ec5a2bde7b8ee99df
+  data.tar.gz: 4d380976e2671b6e8b547543efb9428d356b5f15
+SHA512:
+  metadata.gz: ae0761e2533164dfd36d6dd1fee6ff174a7fe57febeb82ef363ab0fc690a75119d23bbba3f8e464511639924ab6ac1c29b8d02ebc80b88be585bcde25d07becb
+  data.tar.gz: cb58481410216c5d1b4885b10ee00ed08589b97f943d06cc9e5ef22a6f0c0c0f63688060b2cda088812bf6a7b989c0546db7152ee791a2863272701444a65510

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.swp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in weichat_rails.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 qmliu
+
+MIT License
+
+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,30 @@
+# WeichatRails
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'weichat_rails'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install weichat_rails
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( http://github.com/<my-github-username>/weichat_rails/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+touch readme

data/Rakefile

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

data/lib/weichat_rails/access_token.rb

@@ -0,0 +1,34 @@
+module WeichatRails
+  class AccessToken
+    attr_reader :client, :appid, :secret
+
+    CacheScope = "#{Rails.application.class.parent_name}_access_token"
+    def initialize(client, appid, secret)
+      @appid = appid
+      @secret = secret
+      @client = client
+    end
+
+    #store token in rails.cache
+    def token
+      Rails.cache.fetch("#{CacheScope}#{appid}",expires_in: 7200) do
+        data = client.get("token", params:{grant_type: "client_credential", appid: appid, secret: secret})
+        valid_token(data)
+      end
+    end
+
+    #delete the cache
+    def refresh
+      Rails.cache.delete("#{CacheScope}#{appid}")
+    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/weichat_rails/api.rb

@@ -0,0 +1,103 @@
+require 'weichat_rails/client'
+require 'weichat_rails/access_token'
+
+class WeichatRails::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/"
+  KEFU_BASE = "https://api.weixin.qq.com/customservice/"
+  #https://api.weixin.qq.com/cgi-bin/customservice/getkflist?access_token=ACCESS_TOKEN
+
+  def initialize appid, secret
+    @client = WeichatRails::Client.new(API_BASE)
+    @access_token = WeichatRails::AccessToken.new(@client, appid, secret)
+  end
+
+  def users
+    get("user/get")
+  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 kefulist
+    get("customservice/getkflist")
+  end
+
+  def group_get
+    get("groups/get")
+  end
+
+  def group_user_id openid
+    json_str = JSON.generate({openid: openid})
+    post("groups/getid", json_str)
+  end
+
+  def group_update openid, to_groupid
+    json_str = JSON.generate({openid: openid,to_groupid: to_groupid})
+    post("groups/members/update", json_str)
+  end
+
+  def get_duokefu_records time,pageindex
+    json_str = JSON.generate({starttime: time.beginning_of_day.to_i,endtime: time.end_of_day.to_i,pagesize: 50,pageindex: pageindex})
+    post("msgrecord/getrecord",json_str,base: KEFU_BASE)
+  end
+
+  def menu_create menu
+    # 微信不接受7bit escaped json(eg \uxxxx), 中文必须UTF-8编码, 这可能是个安全漏洞
+    # 如果是rails4.0以上使用 to_json 即可，否则使用 JSON.generate(menu,:ascii_only => false)
+    # 但以上试过之后仍是不行，在rails c中却是可以的，所以因该是被其它旧版本的json gem给重写了，所以采用以下方法
+    # 原因找到了是：
+    # 如果传的hash为ActiveSupport::HashWithIndifferentAccess 对像，因为用的是3.2.19，所以其编码可能不对
+    # 直接用 Hash对像的话，用的是ruby 2.0 的方法，做JSON.generate的时候对中文不会再编码成 \uxxxx的形式
+    #
+    json_str = JSON.generate(menu)#.gsub!(/\\u([0-9a-z]{4})/){|u| [$1.to_i(16)].pack('U')}
+
+    post("menu/create", json_str)
+  end
+
+  #返回媒体文件
+  def media media_id
+    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
+
+
+  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 WeichatRails::AccessTokenExpiredError
+      access_token.refresh
+      retry unless (tries -= 1).zero?
+    end
+  end
+
+end
+

data/lib/weichat_rails/auto_generate_secret_key.rb

@@ -0,0 +1,25 @@
+module WeichatRails
+  module AutoGenerateSecretKey
+    extend ActiveSupport::Concern
+
+    included do
+      before_create do
+        self.wechat_secret_key = generate_wechat_secret_key(generator: :urlsafe_base64,size: 16).downcase
+        self.app_token = generate_wechat_secret_key
+      end
+    end
+
+
+    private
+
+    def generate_wechat_secret_key(options={})
+      # SecureRandom: hex, base64, random_bytes, urlsafe_base64, random_number, uuid
+      generator_method_type = options.delete(:generator).try(:to_sym) || :hex
+      generator_method      = SecureRandom.method(generator_method_type)
+      token_size            = options.delete(:size).try(:to_i) || 12
+      return generator_method.call if generator_method_type == :uuid
+      generator_method.call(token_size)
+    end
+
+  end
+end

data/lib/weichat_rails/client.rb

@@ -0,0 +1,81 @@
+require 'rest_client'
+
+module WeichatRails
+  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?)
+        #break data if (parse_as != :json || data["errcode"].blank?)
+
+        #如果返回的是json数据并且errcode有值，则会对errcode再做开关判断
+
+        case data["errcode"]
+        when 0 # for request didn't expect results
+          [true,data]
+
+        when 42001, 40014 #42001: access_token超时, 40014:不合法的access_token
+          raise AccessTokenExpiredError
+
+        when 1613189120 # for wx duokefu' msg code
+          [true,data]
+
+        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)
+
+      else
+        data = response.body
+      end
+
+      return yield(parse_as, data)
+    end
+
+  end
+end
+

data/lib/weichat_rails/message.rb

@@ -0,0 +1,170 @@
+module WeichatRails
+  class Message
+
+    JSON_KEY_MAP = {
+      "ToUserName" => "touser",
+      "MediaId" => "media_id",
+      "ThumbMediaId" => "thumb_media_id"
+    }
+
+    class << self
+      def from_hash msg_hash
+        self.new(msg_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}
+      end
+    end
+
+    attr_reader :message_hash
+
+    def initialize(msg_hash)
+      @message_hash = msg_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
+        WeichatRails.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
+
+    #add wechat_user for load wechat_user in proc callback
+    #def wechat_user user
+    #  update(:wechat_user=>user)
+    #end
+    def kefu msg_type
+      update(:MsgType => msg_type)
+    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))
+        end
+      end
+
+      update(:MsgType=>"news", :ArticleCount=> items.count,
+        :Articles=> items.collect{|item| camelize_hash_keys(item)})
+    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").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")}
+      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/weichat_rails/responder.rb

@@ -0,0 +1,167 @@
+module WeichatRails
+  module Responder
+    extend ActiveSupport::Concern
+
+    included do
+      self.before_filter :init_wechat_or_token#, only: [:show, :create]
+      self.skip_before_filter :verify_authenticity_token
+      self.before_filter :verify_signature, only: [:show, :create]
+      #delegate :wehcat, to: :class
+    end
+
+    attr_accessor :wechat, :token,:wechat_user
+
+
+    module ClassMethods
+
+      #定义整体的处理规则，对于不同的message_type,在block块中进行返回数据处理，
+      #on :text do |res,content|
+      #
+      #end
+      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
+
+
+      #指定的过滤方法，默认不使用指定的匹配方法,如为true,
+      def use_matcher mat = false
+        @use_matcher = mat
+      end
+
+      def use_matcher?
+        @use_matcher
+      end
+
+      #用于处理用户请求，该方法只关注用户信息类型及用户请求的内容或事件信息
+      #事件类型：subscribe(订阅)、unsubscribe(取消订阅),SCAN(关注后扫描)，LOCATION（上报地理位置）,CLICK(自定义菜单事件),VIEW(点击菜单跳转链接时的事件推送)
+      def responder_for message, &block
+        message_type = message[:MsgType].to_sym
+        responders = responders(message_type)
+        if use_matcher?
+          responder = {:method => :find_matcher}
+          case message_type
+          when :text
+            yield(responder,message[:Content])
+          when :event
+            yield(responder,message[:Event],message[:EventKey])
+          when :image,:voice,:shortvideo
+            yield(responder,'MEDIA',picurl: message[:PicUrl],media_id: message[:MediaId])
+          else
+            yield(responder)
+          end
+        else
+          case message_type
+          when :text
+            yield(* match_responders(responders, message[:Content]))
+          when :event
+            yield(* match_responders(responders, message[:Event]))
+          else
+            yield(responders.first)
+          end
+        end
+      end
+
+      private
+
+      #该方法用于确定预先用on定义的返回信息(一个数组 [{with:,proc:,respond:},*args])做循环处理
+      #responds : 预先定义的某类返回信息,类型为[:text, :image, :voice, :video, :location, :link, :event, :fallback]中之一，为一个hash数组
+      #value : 请求内容
+      #优先返回具有with值的on规则
+      #注：使用on定义的规则只适用于直接在控制器中写死的规则，属于类级别，不适用于后台配置类型,如果responders[msg_type]为空的情况下不产生任何内容
+      def match_responders responders, value
+        mat = 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 mat[:scoped] || mat[:general]
+      end
+    end
+
+
+    #用于公众号开发者中心服务器配置中的URL配置,其中xxx为该公众号在开发者数据库中的唯一识别码，由auto_generate_secret_key 来产生
+    #如：http://m.pipgame.com/wx/xxxxx
+    def show
+      render :text => params[:echostr]
+    end
+
+    #创建两个message对像，原请求message及返回message信息，返回的message中传入当前公众号对像，用于回调函数中访问该公众号在数据库中的配置信息
+    def create
+      req = WeichatRails::Message.from_hash(params[:xml] || post_xml)
+      #add whchat_user for multiplay wechat user
+      #req.wechat_user(self.wechat_user)
+      #如果是多客服消息，直接返回
+      response = self.class.responder_for(req) do |responder, *args|
+        responder ||= self.class.responders(:fallback).first
+
+        #next method(responder[:method]).call(*args.unshift(req)) if (responder[:method])
+        next if responder.nil?
+        next find_matcher(*args.unshift(req)) if (responder[:method])
+        next req.reply.text responder[:respond] if (responder[:respond])
+        next responder[:proc].call(*args.unshift(req)) 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.token, params[:timestamp], params[:nonce]].compact.sort
+      render :text => "Forbidden", :status => 403 if params[:signature] != Digest::SHA1.hexdigest(array.join)
+    end
+
+    def post_xml
+      data = Hash.from_xml(reqest.raw_post)
+      HashWithIndifferentAccess.new_from_hash_copying_default data.fetch('xml', {})
+    end
+
+
+    #def wechat_model
+      #@wechat_model || WeichatRails.config.public_account_class.constantize
+    #end
+
+    #TODO init wechat , wechat_user,token from database
+    def init_wechat_or_token
+      raise NotImplementedError, "controller must implement init_wechat_or_token method!if you just need reply,you can init the token,otherwise you need to init whchat and token like: wechat = Wechat::Api.new(opts[:appid], opts[:secret], opts[:access_token]) token = opts[:token]
+      "
+    end
+
+    #need to inplement
+    #在这里处理不同值的内容匹配：subscribe(订阅)、unsubscribe(取消订阅),SCAN(关注后扫描)，LOCATION（上报地理位置）,CLICK(自定义菜单事件),VIEW(点击菜单跳转链接时的事件推送)
+    def find_matcher(req,keyword,event_key=nil)
+      raise NotImplementedError, "controller must implement find_matcher method,eg: get matcher content from database"
+    end
+
+  end
+end
+

data/lib/weichat_rails/version.rb

@@ -0,0 +1,3 @@
+module WeichatRails
+  VERSION = "0.0.1"
+end

data/lib/weichat_rails.rb

@@ -0,0 +1,47 @@
+require "weichat_rails/api"
+require  "weichat_rails/auto_generate_secret_key"
+
+module WeichatRails
+
+  autoload :Message, "weichat_rails/message"
+  autoload :Responder, "weichat_rails/responder"
+
+  class AccessTokenExpiredError < StandardError; end
+
+  class ResponseError < StandardError
+    attr_reader :error_code
+    def initialize(errcode, errmsg)
+      error_code = errcode
+      super "#{errmsg}(#{error_code})"
+    end
+  end
+
+
+  class << self
+    def config
+      @config || OpenStruct.new({wechat_secret_string: nil,wechat_token_string: nil})
+    end
+
+    #can configure the wechat_secret_string,wechat_token_string in weichat_rails_config.rb file
+    def configure
+      yield config if block_given?
+    end
+
+  end
+
+  #DEFAULT_TOKEN_COLUMN_NAME = "wechat_token".freeze
+  #DEFAULT_WECHAT_SECRET_KEY = "wechat_secret_key".freeze
+
+
+  #def self.api
+  # # @api ||= WechatRails::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, WeichatRails::Responder)
+    end
+  end
+end

data/weichat_rails.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'weichat_rails/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "weichat_rails"
+  spec.version       = WeichatRails::VERSION
+  spec.authors       = ["javy_liu"]
+  spec.email         = ["javy_liu@163.com"]
+  spec.summary       = %q{weichat interface for rails based on weichat-rails}
+  spec.description   = %q{weichat use for more than on public weichat account,base on the mysql,~> rails 3.2.16}
+  spec.homepage      = "https://github.com/javyliu/weichat_rails"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+
+  spec.add_dependency "rails", "~> 3.2.14"
+  spec.add_dependency "nokogiri", '>=1.6.0'
+  spec.add_dependency 'rest-client'
+  spec.add_dependency 'dalli'
+
+end

metadata

@@ -0,0 +1,144 @@
+--- !ruby/object:Gem::Specification
+name: weichat_rails
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- javy_liu
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-07-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.2.14
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.2.14
+- !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: dalli
+  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'
+description: weichat use for more than on public weichat account,base on the mysql,~>
+  rails 3.2.16
+email:
+- javy_liu@163.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/weichat_rails.rb
+- lib/weichat_rails/access_token.rb
+- lib/weichat_rails/api.rb
+- lib/weichat_rails/auto_generate_secret_key.rb
+- lib/weichat_rails/client.rb
+- lib/weichat_rails/message.rb
+- lib/weichat_rails/responder.rb
+- lib/weichat_rails/version.rb
+- weichat_rails.gemspec
+homepage: https://github.com/javyliu/weichat_rails
+licenses:
+- MIT
+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: weichat interface for rails based on weichat-rails
+test_files: []
+has_rdoc: