we_chat 0.5.15

data/lib/we_chat/menu.rb

@@ -0,0 +1,36 @@
+require 'we_chat/entity/base'
+
+module WeChat
+  module Menu
+    extend ActiveSupport::Concern
+    include WeChat::Entity::Base
+
+    def to_we_chat_data
+      result = {}
+      result[:name] = self.name
+      if self.top_node?
+        result[:sub_button] = children_to_we_chat_data
+      else
+        result[:type] = self.menu_type
+        if self.view?
+          result[:url] = self.menu_url
+        else
+          result[:key] = self.menu_key
+        end
+      end
+      result
+    end
+
+    def children_to_we_chat_data
+      self.children.inject([]) {|list, item| list << item.to_we_chat_data}
+    end
+
+    included do
+
+    end
+
+    module ClassMethods
+
+    end
+  end
+end

data/lib/we_chat/messaging/message.rb

@@ -0,0 +1,46 @@
+require 'we_chat/symbolizable'
+
+module WeChat
+  module Messaging
+    class Message
+      include WeChat::Symbolizable
+
+      attr_reader :source
+
+      def initialize(hash)
+        @source = symbolize_keys! hash
+      end
+
+      def create_time
+        return nil if source[:CreateTime].nil?
+        Time.at(source[:CreateTime].to_i)
+      end
+
+      def msg_id
+        source[:MsgId].to_i
+      end
+
+      def msg_type
+        source[:MsgType].to_sym
+      end
+
+      def method_missing(method_name, *args, &block)
+        key = method_name.to_s.gsub(/\=/, '').camelize.to_sym
+        if method_name.to_s =~ /.*=$/
+          @source[key] = args.first
+        else
+          return source[key]
+        end
+      end
+
+      def create_response(message_type = :text)
+        response = WeChat::Messaging::Message.new({})
+        response.to_user_name = self.from_user_name
+        response.from_user_name = self.to_user_name
+        response.msg_type = message_type.to_s
+        response.create_time = Time.now.to_i
+        response
+      end
+    end
+  end
+end

data/lib/we_chat/messaging/message_validator.rb

@@ -0,0 +1,15 @@
+
+module WeChat
+  module Messaging
+    class MessageValidator
+
+      def self.is_valid?(signature, timestamp, nonce, token)
+        tmpArray = [token, timestamp, nonce].sort
+        tmpString = tmpArray.join
+        new_signature = Digest::SHA1.hexdigest tmpString
+        return false if signature.nil?
+        new_signature == signature
+      end
+    end
+  end
+end

data/lib/we_chat/messaging/responder.rb

@@ -0,0 +1,92 @@
+require 'active_support/concern'
+require 'we_chat/messaging/message'
+require 'we_chat/messaging/message_validator'
+
+module WeChat
+  module Messaging
+    module Responder
+      extend ActiveSupport::Concern
+
+      included do
+        self.skip_before_filter :verify_authenticity_token
+        self.before_filter :verify_signature, only: [:show, :create]
+      end
+
+      def show
+        render :text => params[:echostr]
+      end
+
+      def create
+        request_message = WeChat::Messaging::Message.new(params[:xml] || post_data)
+        response = self.class.create_response(request_message)
+        if response.nil?
+          Rails.logger.debug 'response is null'
+          render nothing: true, status: 200, content_type: 'text/html'
+        else
+          render xml: response.source.to_xml(root: 'xml')
+        end
+      end
+
+      def verify_signature
+        array = [WeChat.wechat_token, params[:timestamp], params[:nonce]].compact.collect(&:to_s).sort
+        Rails.logger.debug Digest::SHA1.hexdigest(array.join)
+        render :text => "Forbidden", :status => 403 if params[:signature] != Digest::SHA1.hexdigest(array.join)
+      end
+
+      def post_data
+        data = Hash.from_xml(request.raw_post)
+        HashWithIndifferentAccess.new_from_hash_copying_default data.fetch('xml', {})
+      end
+
+      module ClassMethods
+        attr_reader :responders
+
+        def responds(message_type = :text, options={}, &block)
+          return unless block_given?
+          pattern = options.delete(:pattern) || /.*/
+          initialize_responders(message_type)
+          @responders[message_type] << { pattern: pattern, proc: block }
+        end
+
+        def create_response(message)
+          response_data = nil
+          responder_item = matched_responder(message)
+          return nil if responder_item.nil?
+
+          case message.msg_type
+          when :text
+            response_result = responder_item[:proc].call(message)
+            return nil if response_result.nil?
+            return response_result if response_result.is_a? WeChat::Messaging::Message
+            return create_text_message_response(message, response_result) if response_result.is_a? String
+          end
+        end
+
+      private
+
+        def initialize_responders(message_type)
+          @responders ||= {}
+          @responders[message_type] ||= []
+        end
+
+        def matched_responder(message)
+          initialize_responders(message.msg_type)
+          responders[message.msg_type].each do |item|
+            if item[:pattern].is_a? Regexp
+              return item if message.content =~ item[:pattern]
+            else #String
+              return item if message.content.downcase == item[:pattern].downcase
+            end
+          end
+          nil
+        end
+
+        def create_text_message_response(message, reply_content)
+          response = message.create_response
+          response.content = reply_content
+          return response
+        end
+      end
+    end
+  end
+end

data/lib/we_chat/multipart_ext.rb

@@ -0,0 +1,12 @@
+# HTTP::FormData::Multipart hacking
+# Adding an additional CRLF at the end of request body
+
+CRLF = "\r\n".freeze
+
+HTTP::FormData::Multipart.class_eval do
+  alias_method :_real_tail, :tail
+
+  def tail
+    @tail ||= "#{CRLF}--#{@boundary}--#{CRLF}"
+  end
+end

data/lib/we_chat/product.rb

@@ -0,0 +1,119 @@
+require 'we_chat/entity/base'
+require 'we_chat/rest/client'
+
+module WeChat
+  module Product
+    extend ActiveSupport::Concern
+
+    include WeChat::Entity::Base
+
+    CHILDREN = {
+      sku: :sku_list,
+      category: :category_id,
+      category_property_item: :property,
+      product_attribute: :attrext}.freeze
+
+    def to_we_chat_data
+      we_chat_data = {}
+      we_chat_data[:product_id] = self.we_chat_id
+      we_chat_data[:product_base] = {}
+      we_chat_data[:product_base][:name] = self.name
+      we_chat_data[:product_base][:buy_limit] = self.buy_limit
+      we_chat_data[:product_base][:main_img] = self.main_image_url
+      we_chat_data[:product_base][:detail_html] = self.description
+
+      we_chat_data[:product_base][:category_id] = []
+      self.categories.each { |category| we_chat_data[:product_base][:category_id] << category.we_chat_id }
+
+      we_chat_data[:product_base][:property] = []
+      self.category_property_items.each { |property_item| we_chat_data[:product_base][:property] << { id: property_item.category_property.we_chat_id, vid: property_item.we_chat_id } }
+
+      we_chat_data[:product_base][:sku_list] = []
+      we_chat_data[:product_base][:sku_info] = []
+      self.skus.each do |sku|
+        we_chat_data[:product_base][:sku_list] << sku.to_we_chat_data
+
+        if sku.sku_definition_items.length > 0
+          sku.sku_definition_items.each do |sku_definition_item|
+            index = we_chat_data[:product_base][:sku_info].index { |item| item[:id] == sku_definition_item.sku_definition.we_chat_id }
+            sku_info_data = {id: sku_definition_item.sku_definition.we_chat_id, vid: []}
+            if index && index >= 0
+              sku_info_data = we_chat_data[:product_base][:sku_info][index]
+            else
+              we_chat_data[:product_base][:sku_info] << sku_info_data
+            end
+
+            sku_info_data[:vid] << sku_definition_item.we_chat_id unless sku_info_data[:vid].include?(sku_definition_item.we_chat_id)
+          end
+        end
+      end
+
+      we_chat_data
+    end
+
+    def get_we_chat_id_from_data(data)
+      data[:product_id]
+    end
+
+    included do
+    end
+
+    module ClassMethods
+
+      def get_instance_data_from_reponse(response)
+        response[:product_info]
+      end
+
+      def prepare_instance_data(data)
+        result = {}
+        result[:we_chat_id] = data[:product_id]
+        result[:name]       = data[:product_base][:name]
+        result[:buy_limit]  = data[:product_base][:buy_limit]
+        result[:main_image_url] = data[:product_base][:main_img]
+        result[:description] = data[:product_base][:detail_html]
+        result
+      end
+
+      def prepare_one_type_of_children_data(data, child_type, definition)
+        if [:category, :category_property_item].include?(child_type)
+          data_key = definition[:data_key]
+          definition.merge(data: data[:product_base][data_key])
+        else
+          super(data, child_type, definition)
+        end
+      end
+
+      def prepare_one_type_of_children(instance, child_type, child_data)
+        case child_type
+        when :category
+          child_data[:data].each do |category_id|
+            child_instance = child_data[:klass].send(:find_by_we_chat_id, category_id)
+            instance.send(child_data[:method]) << child_instance if child_instance
+          end
+        when :category_property_item
+          child_data[:data].each do |item|
+            category_property_id = item[:id]
+            category_property_item_id = item[:vid]
+
+            child_instance = child_data[:klass].send(:find_by_we_chat_id, category_property_item_id)
+            instance.send(child_data[:method]) << child_instance if child_instance
+          end
+        when :product_attribute
+          child_data[:data].map do |key, value|
+            if key != :location
+              child_instance = child_data[:klass].send(:create_by_we_chat_data, { key: key.to_s.underscore, value: value, we_chat_id: key.to_s })
+              instance.send(child_data[:method]) << child_instance if child_instance
+            else
+              value.map do |k, v|
+                child_instance = child_data[:klass].send(:create_by_we_chat_data, { key: "location.#{k.to_s.underscore}", value: v, we_chat_id: k.to_s })
+                instance.send(child_data[:method]) << child_instance if child_instance
+              end
+            end
+          end
+        else
+          super(instance, child_type, child_data)
+        end
+      end
+    end
+  end
+end

data/lib/we_chat/product_attribute.rb

@@ -0,0 +1,23 @@
+require 'we_chat/entity/base'
+
+module WeChat
+  module ProductAttribute
+    extend ActiveSupport::Concern
+    include WeChat::Entity::Base
+
+    included do
+    end
+
+    module ClassMethods
+
+      def prepare_instance_data(data)
+        result = super data
+        result[:key] = data[:key]
+        result[:value] = data[:value]
+        result[:we_chat_id] = data[:we_chat_id]
+        result
+      end
+
+    end
+  end
+end

data/lib/we_chat/rest/api.rb

@@ -0,0 +1,17 @@
+require 'we_chat/rest/user'
+require 'we_chat/rest/menu'
+require 'we_chat/rest/store'
+require 'we_chat/rest/media'
+require 'we_chat/rest/template_message'
+
+module WeChat
+  module REST
+    module API
+      include WeChat::REST::User
+      include WeChat::REST::Menu
+      include WeChat::REST::Store
+      include WeChat::REST::Media
+      include WeChat::REST::TemplateMessage
+    end
+  end
+end

data/lib/we_chat/rest/client.rb

@@ -0,0 +1,41 @@
+require 'we_chat/rest/api'
+require 'we_chat/access_token'
+
+module WeChat
+  module REST
+    class Client
+      include WeChat::REST::API
+
+      attr_accessor :access_token
+
+      class << self
+        def default
+          new(access_token: WeChat::AccessToken.get_access_token)
+        end
+      end
+
+      def initialize(options = {})
+        options.each do |key, value|
+          instance_variable_set("@#{key}", value)
+        end
+        yield(self) if block_given?
+      end
+
+      def access_token?
+        !!access_token
+      end
+
+      # @return [Hash]
+      def credentials
+        {
+          access_token: access_token,
+        }
+      end
+
+      # @return [Boolean]
+      def credentials?
+        credentials.values.all?
+      end
+    end
+  end
+end

data/lib/we_chat/rest/media.rb

@@ -0,0 +1,18 @@
+require 'we_chat/rest/utils'
+
+module WeChat
+  module REST
+    module Media
+      include WeChat::REST::Utils
+
+      def upload(media, type)
+        perform_multipart_post('/media/upload', { key: 'media', file: media, params: { type: type } })
+      end
+
+      def upload_image(file_path)
+        upload(file_path, 'image')
+      end
+
+    end
+  end
+end

data/lib/we_chat/rest/menu.rb

@@ -0,0 +1,21 @@
+require 'we_chat/rest/utils'
+
+module WeChat
+  module REST
+    module Menu
+      include WeChat::REST::Utils
+
+      def menu_get
+        perform_get('/menu/get')
+      end
+
+      def menu_create(data)
+        perform_post('/menu/create', data)
+      end
+
+      def menu_delete
+        perform_get('/menu/delete')
+      end
+    end
+  end
+end

data/lib/we_chat/rest/request.rb

@@ -0,0 +1,103 @@
+require 'http'
+require "addressable/template"
+require 'we_chat/symbolizable'
+require 'we_chat/multipart_ext'
+require 'we_chat/headers'
+require 'we_chat/error'
+
+module WeChat
+  module REST
+    class Request
+      include WeChat::Symbolizable
+
+      attr_accessor :client, :headers, :options, :path,
+                    :request_method, :uri
+      alias_method :verb, :request_method
+
+      def initialize(_client, request_method, path, options = {})
+        @client = _client
+        request_params = options.delete(:params) unless options[:params].nil?
+        request_params ||= {}
+        request_params[:access_token] = @client.access_token if @client.access_token?
+        template = ::Addressable::Template.new(path.start_with?('http') ? path : WeChat.wechat_api_base_url + path + "{?query*}")
+        @uri = template.expand({
+          "query" => request_params
+        })
+        set_multipart_options!(request_method, options)
+        @path = uri.path
+        @options = options
+      end
+
+      # @return [Array, Hash]
+      def perform
+        options_key = @request_method == :get ? :params : @request_method == :post ? :json : :form
+        response = HTTP.with(@headers).public_send(@request_method, @uri.to_s, options_key => @options)
+        fail_or_return_response_body(response)
+      end
+
+      private
+
+      def set_multipart_options!(request_method, options)
+        if request_method == :multipart_post
+          key, file = options.delete(:key), options.delete(:file)
+          options.merge!(key => HTTP::FormData::File.new(file, filename: File.basename(file), mime_type: mime_type(File.basename(file))))
+          # @request_method = :post
+          @headers = WeChat::Headers.new(@client, @request_method, @uri).request_headers
+        else
+          @request_method = request_method
+          @headers = WeChat::Headers.new(@client, @request_method, @uri, options).request_headers
+        end
+      end
+
+      def mime_type(basename)
+        case basename
+        when /\.gif$/i
+          'image/gif'
+        when /\.jpe?g/i
+          'image/jpeg'
+        when /\.png$/i
+          'image/png'
+        else
+          'application/octet-stream'
+        end
+      end
+
+      def fail_or_return_response_body(response)
+        response_body = symbolize_keys!(response.parse) if response.status.ok?
+        response_body ||= response.body.to_s
+        error = error(response, response_body, response.headers)
+        fail(error) if error
+        response_body
+      end
+
+      def error(response, body, headers)
+        error_entity = nil
+        if response.status.ok?
+          error_entity = WeChat::Error.from_response(body, headers) if contains_error?(body)
+        else
+          klass = WeChat::Error::ERRORS[response.code]
+          if klass == WeChat::Error::Forbidden
+            error_entity = forbidden_error(body, headers)
+          elsif !klass.nil?
+            error_entity = klass.from_response(nil, headers)
+          end
+        end
+        error_entity
+      end
+
+      def contains_error?(body)
+        body[:errcode] && body[:errcode] != 0
+      end
+
+      def forbidden_error(body, headers)
+        error = WeChat::Error::Forbidden.from_response(body, headers)
+        klass = WeChat::Error::FORBIDDEN_MESSAGES[error.message]
+        if klass
+          klass.from_response(body, headers)
+        else
+          error
+        end
+      end
+    end
+  end
+end