diandian-oauth 0.0.3 → 0.1.1

data/Gemfile

@@ -3,3 +3,4 @@ source 'http://rubygems.org'
 gem 'oauth2', '~> 0.8.0'
 gem 'activemodel', '~> 3.2.6'
 gem 'activesupport', ' ~> 3.2.1'
+gem 'faraday', :git => "https://github.com/secretworry/faraday.git"

data/Gemfile.lock

@@ -1,3 +1,10 @@
+GIT
+  remote: https://github.com/secretworry/faraday.git
+  revision: b34ecbb6cd4d0b2280cdb19a15f1d39a9b0eb309
+  specs:
+    faraday (0.8.0)
+      multipart-post (~> 1.1)
+
 GEM
   remote: http://rubygems.org/
   specs:
@@ -8,8 +15,6 @@ GEM
       i18n (~> 0.6)
       multi_json (~> 1.0)
     builder (3.0.0)
-    faraday (0.8.1)
-      multipart-post (~> 1.1)
     httpauth (0.1)
     i18n (0.6.0)
     jwt (0.1.5)
@@ -30,4 +35,5 @@ PLATFORMS
 DEPENDENCIES
   activemodel (~> 3.2.6)
   activesupport (~> 3.2.1)
+  faraday!
   oauth2 (~> 0.8.0)

data/diandian-oauth.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name        = 'diandian-oauth'
-  s.version     = '0.0.3'
+  s.version     = '0.1.1'
   s.date        = '2012-07-24'
   s.summary     = "Client for diandian API"
   s.description = "A Ruby Client for diandian API"

data/lib/diandian_oauth.rb

@@ -1,10 +1,11 @@
+require 'active_support/core_ext'
 require 'diandian_oauth/api'
 require 'diandian_oauth/client'
 require 'diandian_oauth/exceptions'
-require 'active_support/core_ext'
+require 'diandian_oauth/models/response'
 require 'logger'
 module DiandianOAuth
-	VERSION = '0.0.3'
+	VERSION = '0.1.1'
   module Logger
     def logger *args
       if args.empty?
@@ -16,4 +17,4 @@ module DiandianOAuth
   end
   extend Logger
   logger STDOUT
-end
+end

data/lib/diandian_oauth/api.rb

@@ -18,15 +18,22 @@ module DiandianOAuth
     interface :user_likes, Interface::UserLikes
     interface :user_followings, Interface::UserFollowings
     interface :my_tags, Interface::MyTags
-    interface :blog, Interface::Blog
     interface :blog_info, Interface::BlogInfo
     interface :blog_avatar, Interface::BlogAvatar
     interface :blog_followers, Interface::BlogFollowers
     interface :posts, Interface::Posts
+    interface :post_info, Interface::PostInfo
+    interface :create_post, Interface::CreatePost
+    interface :delete_post, Interface::DeletePost
+    interface :reblog_post, Interface::ReblogPost
     interface :home_feeds, Interface::HomeFeeds
     interface :tag_feeds, Interface::TagFeeds
     interface :follow, Interface::Follow
     interface :unfollow, Interface::Unfollow
+    interface :watch_tag, Interface::WatchTag
+    interface :unwatch_tag, Interface::UnwatchTag
     interface :submissions, Interface::Submissions
+    interface :submit, Interface::Submit
+    interface :reject_submission, Interface::RejectSubmission
 	end
 end

data/lib/diandian_oauth/api/interface.rb

@@ -1,4 +1,3 @@
-
 module DiandianOAuth
   class API
     module Interface
@@ -40,20 +39,43 @@ module DiandianOAuth
         end
       end #Param
 
+      class Params
+        def initialize(params = {})
+          @params = params.symbolize_keys!
+        end
+        def [] key
+          @params[key.to_sym]
+        end
+
+        def []= key, value
+          @params[key.to_sym] = value
+        end
+
+        def to_a
+          @params.reduce([]) do |all, (key, value)|
+            case value
+              when Array
+                value.each{|v| all << [key, v]}
+              else
+                all << [key, value]
+            end
+            all
+          end
+        end
+
+        def to_h
+          @params
+        end
+      end
+
       class Base
         def request_url params = {}
           raise 'subclasses must implement this method'
         end
 
-        # when the access_token is out-of-date, refresh it automatically
-        def apply! access_token, params, &block
-          access_token.refresh! if access_token.expired?
-          self.apply access_token, params, &block
-        end
-
         def apply access_token, params, &block
-          raise TokenExpiredException if access_token.expired?
-          params ||= {}
+          raise TokenExpiredError if access_token.expired?
+          params = Params.new( params || {})
           action = case request_verb
           when /get/ then :get
           when /post/ then :post
@@ -62,30 +84,27 @@ module DiandianOAuth
           else raise "unrecognized verb '#{request_verb}'"
           end # case
           options = {
-            :params => extract_params(params),
+            :body => extract_params(params).to_a,
             :raise_errors => false,
             :parse => :json
           }
           request_url = self.request_url(params)
           if DiandianOAuth.logger.debug?
-            DiandianOAuth.logger.debug("request with action:'#{action}', request_url:'#{request_url}'")
+            DiandianOAuth.logger.debug("request with action:'#{action}', request_url:'#{request_url}', options:'#{options}'")
           end
-          access_token.request( action, request_url, options, &block)
+          DiandianOAuth::Response.from_response access_token.request( action, request_url, options, &block)
         end
         protected
         def request_verb
           self.class.verb
         end
         def extract_params params
-          params.symbolize_keys!
-          self.class.params.each_pair.reduce({}) do |result, ele|
-            key = ele[0]
-            param = ele[1]
+          self.class.params.reduce(Params.new) do |result, (key, value)|
             param_value = params[key]
-            if param_value && param.required
+            if param_value
               result[key] = param_value
-            elsif param.required
-              raise ParamIsRequiredException.new( "'#{key}' is required")
+            elsif value.required
+              raise ParamIsRequiredError.new( "'#{key}' is required")
             end
             result
           end
@@ -137,8 +156,9 @@ module DiandianOAuth
         protected
         def blog_request_url params
           blog_cname = params[:blogCName]
-          raise ParamIsRequiredException.new("blogCName is required for interface #{self.class.name}") unless blog_cname
-          API.url_for "/blog/#{blog_cname}"
+          blog_uuid = params[:blogUuid]
+          raise ParamIsRequiredError.new("blogCName or blogUuid is required for interface #{self.class.name}") unless blog_cname || blog_uuid
+          API.url_for "/blog/#{blog_cname||blog_uuid}"
         end
       end #BlogInterface
 
@@ -155,7 +175,7 @@ module DiandianOAuth
           size = params[:size]
           if size
             unless BlogAvatar.is_valid_size size
-              raise IllegalParamException.new("'#{size}' is illegal")
+              raise IllegalParamError.new("'#{size}' is illegal")
             end
           end # if
         end
@@ -166,13 +186,24 @@ module DiandianOAuth
 
       end #BlogAvatar
 
+      class PostInfo < Base
+        param :id, :required => true
+        def request_url params={}
+          blog_cname = params[:blogCName]
+          blog_uuid = params[:blogUuid]
+          raise ParamIsRequiredError.new("blogCName or blogUuid is required for interface #{self.class.name}") unless blog_cname || blog_uuid
+          API.url_for "/blog/#{blog_cname || blog_uuid}/posts"
+        end
+      end
+
       class BlogFollowers < Base
         param :limit, :required => false
         param :offset, :required => false
         def request_url params={}
           blog_cname = params[:blogCName]
-          raise ParamIsRequiredException.new("blogCName is required for interface #{self.class.name}") unless blog_cname
-          API.url_for "/blog/#{blog_cname}/info"
+          blog_uuid = params[:blogUuid]
+          raise ParamIsRequiredError.new("blogCName or blogUuid is required for interface #{self.class.name}") unless blog_cname || blog_uuid
+          API.url_for "/blog/#{blog_cname || blog_uuid}/info"
         end
       end #BlogFollowers
 
@@ -186,8 +217,9 @@ module DiandianOAuth
         param :filter, :required => false
         def request_url params={}
           blog_cname = params[:blogCName]
-          raise ParamIsRequiredException.new("blogCName is required for interface #{self.class.name}") unless blog_cname
-          path = "/blog/#{blog_cname}/posts"
+          blog_uuid = params[:blogUuid]
+          raise ParamIsRequiredError.new("blogCName or blogUuid is required for interface #{self.class.name}") unless blog_cname || blog_uuid
+          path = "/blog/#{blog_cname||blog_uuid}/posts"
           if params[:type]
             path = path + "/#{type}"
           end
@@ -195,6 +227,107 @@ module DiandianOAuth
         end
       end # Posts
 
+      class CreatePost < Base
+        verb :post
+        param :type, :required => true
+        param :state, :required => true
+        param :tag, :required => false
+        param :slug, :required => false
+        #text
+        param :title, :required => false
+        param :body, :required => false
+        #photo
+        param :caption, :required => false
+        param :layout, :required => false
+        param :data, :required => false
+        param :itemDesc, :required => false
+        #link
+        param :title, :required => false
+        param :url, :required => false
+        param :description, :required => false
+
+        #audio
+        param :caption, :required => false
+        param :data, :required => false
+        param :musicName, :required => false
+        param :musicSinger, :required => false
+        param :albumName, :required => false
+
+        #video
+        param :caption, :required => false
+        param :sourceUrl, :required => false
+
+        def request_url params={}
+          blog_cname = params[:blogCName]
+          blog_uuid = params[:blogUuid]
+          raise ParamIsRequiredError.new("blogCName or blogUuid is required for interface #{self.class.name}") unless blog_cname || blog_uuid
+          API.url_for "/blog/#{blog_cname || blog_uuid}/post"
+        end
+      end
+
+      class EditPost < Base
+        verb :post
+        param :id, :required => true
+        param :tag, :required => false
+        param :slug, :required => false
+        #text
+        param :title, :required => false
+        param :body, :required => false
+        #photo
+        param :caption, :required => false
+        param :layout, :required => false
+        param :data, :required => false
+        param :itemDesc, :required => false
+        #link
+        param :title, :required => false
+        param :url, :required => false
+        param :description, :required => false
+
+        #audio
+        param :caption, :required => false
+        param :data, :required => false
+        param :musicName, :required => false
+        param :musicSinger, :required => false
+        param :albumName, :required => false
+
+        #video
+        param :caption, :required => false
+        param :sourceUrl, :required => false
+
+        def request_url params={}
+          blog_cname = params[:blogCName]
+          blog_uuid = params[:blogUuid]
+          raise ParamIsRequiredError.new("blogCName or blogUuid is required for interface #{self.class.name}") unless blog_cname || blog_uuid
+          type = params[:type]
+          raise ParamIsRequiredError.new("type is required for interface #{self.class.name}") unless type
+          API.url_for "/blog/#{blog_cname || blog_uuid}/post/edit"
+        end
+      end
+
+      class DeletePost < Base
+        verb :post
+        param :id, :required => true
+        def request_url params={}
+          blog_cname = params[:blogCName]
+          blog_uuid = params[:blogUuid]
+          raise ParamIsRequiredError.new("blogCName or blogUuid is required for interface #{self.class.name}") unless blog_cname || blog_uuid
+          API.url_for "/blog/#{blog_cname || blog_uuid}/post/delete"
+        end
+      end
+
+      class ReblogPost < Base
+        verb :post
+        param :id, :required => true
+        param :tag, :required => false
+        param :comment, :required => false
+        def request_url params={}
+          blog_cname = params[:blogCName]
+          blog_uuid = params[:blogUuid]
+          raise ParamIsRequiredError.new("blogCName or blogUuid is required for interface #{self.class.name}") unless blog_cname || blog_uuid
+          API.url_for "/blog/#{blog_cname || blog_uuid}/post/reblog"
+        end
+      end
+
       class HomeFeeds < Base
         param :limit, :required => false
         param :offset, :required => false
@@ -218,7 +351,7 @@ module DiandianOAuth
 
         def request_url params={}
           tag = params[:tag]
-          raise ParamIsRequiredException("tag is required for interface #{self.class.name}") unless tag
+          raise ParamIsRequiredError.new("tag is required for interface #{self.class.name}") unless tag
           API.url_for "/tag/posts/#{tag}"
         end
       end #TagFeeds
@@ -239,11 +372,81 @@ module DiandianOAuth
         end
       end # Unfollow
 
+      class WatchTag < Base
+        verb :post
+        def request_url params={}
+          tag = params[:tag]
+          raise ParamIsRequiredError.new("tag is required for interface #{self.class.name}") unless tag
+          API.url_for '/tag/watch/#{tag}'
+        end
+      end
+
+      class UnwatchTag < Base
+        verb :post
+        def request_url params={}
+          tag = params[:tag]
+          raise ParamIsRequiredError.new("tag is required for interface #{self.class.name}") unless tag
+          API.url_for '/tag/watch/#{tag}'
+        end
+      end
+
       class Submissions < Base
         def request_url params={}
           blog_cname = params[:blogCName]
-          raise ParamIsRequiredException("blogCName is required for interface #{self.class.name}") unless blog_cname
-          API.url_for "/blog/#{blog_cname}/submission"
+          blog_uuid = params[:blogUuid]
+          raise ParamIsRequiredError.new("blogCName or blogUuid is required for interface #{self.class.name}") unless blog_cname || blog_uuid
+          API.url_for "/blog/#{blog_cname||blog_uuid}/submission"
+        end
+      end #Submissions
+
+      class Submit < Base
+        verb :post
+        param :tag, :required => false
+        param :slug, :required => false
+        #text
+        param :title, :required => false
+        param :body, :required => false
+        #photo
+        param :caption, :required => false
+        param :layout, :required => false
+        param :data, :required => false
+        param :itemDesc, :required => false
+        #link
+        param :title, :required => false
+        param :url, :required => false
+        param :description, :required => false
+
+        #audio
+        param :caption, :required => false
+        param :data, :required => false
+        param :musicName, :required => false
+        param :musicSinger, :required => false
+        param :albumName, :required => false
+
+        #video
+        param :caption, :required => false
+        param :sourceUrl, :required => false
+
+        def request_url params={}
+          blog_cname = params[:blogCName]
+          blog_uuid = params[:blogUuid]
+          raise ParamIsRequiredError.new("blogCName or blogUuid is required for interface #{self.class.name}") unless blog_cname || blog_uuid
+          type = params[:type]
+          raise ParamIsRequiredError.new("type is required for interface #{self.class.name}") unless type
+          API.url_for "/blog/#{blog_cname || blog_uuid}/submission/#{type}"
+        end
+      end
+
+      class RejectSubmission < Base
+        verb :post
+        param :reason, :required => false
+        def request_url params={}
+          blog_cname = params[:blogCName]
+          blog_uuid = params[:blogUuid]
+          raise ParamIsRequiredError.new("blogCName or blogUuid is required for interface #{self.class.name}") unless blog_cname || blog_uuid
+          id = params[:id]
+          raise ParamIsRequiredError.new("id is required for interface #{self.class.name}") unless id
+          API.url_for "/blog/#{blog_cname || blog_uuid}/submission/reject/#{id}"
         end
       end
     end # Interface

data/lib/diandian_oauth/client.rb

@@ -1,7 +1,9 @@
 require 'oauth2'
+require 'diandian_oauth/client/callbacks'
 module DiandianOAuth
 	class Client
-		attr_accessor :api
+    include DiandianOAuth::Client::Callbacks
+		attr_accessor :api, :client
 		def initialize client_id, client_secret, options={}
       @api = options[:api] || DiandianOAuth::API.new
       @redirect_uri = options[:redirect_uri]
@@ -9,7 +11,16 @@ module DiandianOAuth
           :authorize_url => @api.authorize_url,
           :token_url => @api.token_url
         }
-		end
+      self.config_client_middleware(@client)
+    end
+
+    def config_client_middleware client
+      client.options[:connection_build] = Proc.new do |builder|
+        builder.request :multipart
+        builder.request :url_encoded
+        builder.adapter :net_http
+      end
+    end
 
 		def authorize_url response_type='code', scope=[]
       if response_type.is_a? Array
@@ -38,13 +49,14 @@ module DiandianOAuth
       else
         begin
           DiandianOAuth.logger.warn('redirect_url is required for authorization_code grant type') unless @redirect_uri
-          @access_token = @client.get_token(
-              :client_id => @client.id,
-              :client_secret => @client.secret,
-              :grant_type => 'authorization_code',
-              :code => code_or_hash,
-              :redirect_uri => @redirect_uri
-          )
+          @access_token = @client.auth_code.get_token(code_or_hash, {:redirect_uri => @redirect_uri})
+          #@access_token = @client.get_token(
+          #    :client_id => @client.id,
+          #    :client_secret => @client.secret,
+          #    :grant_type => 'authorization_code',
+          #    :code => code_or_hash,
+          #    :redirect_uri => @redirect_uri
+          #)
         rescue OAuth2::Error => e
           DiandianOAuth.logger.error e.to_s
           raise e
@@ -60,8 +72,24 @@ module DiandianOAuth
 			if interface
         access_token = self.access_token
         raise 'access_token is required' unless access_token
-        if force
-          interface.apply! access_token, args[0], &block
+        response = if force
+          begin
+            token_expired = false
+            response = interface.apply access_token, args[0], &block
+            response.validate!
+          rescue TokenExpiredError => e
+            if DiandianOAuth.logger.debug?
+              DiandianOAuth.logger.debug("token '#{access_token.inspect}' expired")
+            end
+            new_access_token = access_token.refresh!
+            self.token_refreshed new_access_token
+            if DiandianOAuth.logger.debug?
+              DiandianOAuth.logger.debug("refreshed '#{access_token.inspect}' with '#{new_access_token}'")
+            end
+            self.access_token = access_token = new_access_token
+            token_expired = true
+          end while token_expired
+          response
         else
 				  interface.apply access_token, args[0], &block
         end # force

data/lib/diandian_oauth/client/callbacks.rb

@@ -0,0 +1,49 @@
+module DiandianOAuth
+  class Client
+    module Callbacks
+      class Callback
+        attr_accessor :executor
+        def initialize proc_or_method
+          self.executor = proc_or_method
+        end
+        def apply client, *args, &block
+          case executor
+            when Symbol then client.send(executor, *args, &block)
+            when Proc then executor.call( client, *args, &block)
+          end
+        end
+      end
+      def self.included base
+        base.extend ClassMethods
+        base.send :include, InstanceMethods
+        base.class_eval do
+          self.callbacks = {}
+        end
+      end
+
+      module ClassMethods
+        def callbacks name=nil
+          if name
+            @callbacks[name] ||= []
+          else
+            @callbacks
+          end
+        end
+        def callbacks= callbacks
+          @callbacks = callbacks
+        end
+        def token_refreshed proc_or_method
+          self.callbacks(:token_refreshed) << Callback.new( proc_or_method)
+        end
+        private
+      end
+      module InstanceMethods
+        def token_refreshed access_token
+          self.class.callbacks[:token_refreshed].each do |callback|
+            callback.apply(self, access_token)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/diandian_oauth/exceptions.rb

@@ -1,19 +1,236 @@
 module DiandianOAuth
 
-  class OAuthException < ::Exception
+  class Error < ::StandardError
   end
 
-  class TokenExpiredException < OAuthException
+  class TokenExpiredError < Error
   end
 
-  class RefreshTokenExpireException < OAuthException
+  class RefreshTokenExpireError < Error
   end
   # APIException
-  class APIException < OAuthException
+  class APIError < Error
   end
-  class ParamIsRequiredException < APIException
+
+  class ResponseError < APIError
+  end
+
+  class InvalidateRequestError < ResponseError
+
+  end
+
+  class UnauthorizedClientError < ResponseError
+
+  end
+
+  class AccessDeniedError < ResponseError
+
+  end
+
+  class UnsupportedResponseTypeError < ResponseError
+
+  end
+
+  class InvalidScopeError < ResponseError
+
+  end
+
+  class TemporarilyUnavailableError < ResponseError
+
+  end
+
+  class ParamIsRequiredError < APIError
+  end
+  class IllegalParamError < APIError
+  end
+  ## 400000
+  class ClientError < APIError
+  end
+
+  ## 400001
+  class ParameterError < APIError
+
+  end
+
+  ## 400010
+  class EmailError < APIError
+  end
+
+  ## 400011
+  class PasswordError < APIError
+  end
+
+  ## 400012
+  class EccentricAccountError < APIError
+
+  end
+
+  ## 400013
+  class EmailFormatError < APIError
+
+  end
+
+  ## 400014
+  class PasswordFormatError < APIError
+
+  end
+
+  ## 400015
+  class EmailExistsError < APIError
+
+  end
+
+
+
+  ## 400020
+  class BindingFailError < APIError
+
+  end
+
+  ## 40003x
+  class RelationError < APIError
+
+  end
+
+  ## 400030
+  class FollowError < RelationError
+
+  end
+  ## 400031
+  class UnfollowError < RelationError
+
+  end
+
+  ## 400040
+  class IllegalContentError < APIError
+
+  end
+
+  ## 40005x
+  class InboxError < APIError
+
+  end
+
+  ## 400050
+  class InboxContentCannotBeEmptyError < APIError
+
+  end
+
+  ## 400051
+  class InboxContentTooLongError < APIError
+
   end
-  class IllegalParamException < APIException
+
+  ## 400052
+  class InboxClosedError < APIError
+
+  end
+
+  ## 400053
+  class CannotSendToOwnBlogError < APIError
+
+  end
+
+  ## 400060
+  class OperationTooFastError < APIError
+
+  end
+
+  ## 400070
+  class BlogClosedError < APIError
+
+  end
+
+
+  ## 40008x
+  class VerifyCodeError < APIError
+
+  end
+
+  ## 400080
+  class VerifyCodeExpiredError < VerifyCodeError
+
+  end
+
+
+  ## 400081
+  class VerifyCodeWrongError < VerifyCodeError
+
   end
+
+  ## 401xxx
+  class AuthorizationError < APIError
+  end
+
+  ## 401000
+  class UnauthorizedError < AuthorizationError
+
+  end
+
+  ## 403xxx
+  class ForbiddenError < APIError
+
+  end
+
+  ## 403000
+  class VisitForbiddenError < ForbiddenError
+
+  end
+
+  ## 403001
+  class BlogManagerRequiredError < ForbiddenError
+
+  end
+
+  ## 404xxx
+  class NotFoundError < APIError
+
+  end
+
+  ## 404000
+  class UrlNotFoundError < NotFoundError
+
+  end
+
+  ## 404002
+  class BlogNotFoundError < NotFoundError
+
+  end
+
+  ## 404003
+  class ContentNotFoundError < NotFoundError
+
+  end
+
+  ## 404004
+  class UserNotFoundError < NotFoundError
+
+  end
+
+  ## 500xxx
+  class ServerError < APIError
+
+  end
+
+  ## 500000
+  class InternalServerError < APIError
+
+  end
+
+  ## 500001
+  class PostTypeError < APIError
+
+  end
+
+  ## 500002
+  class InboxError < APIError
+
+  end
+
+  ## 503001
+  class UpgradingError < APIError
+
+  end
+
   # End APIException
 end

data/lib/diandian_oauth/models/response.rb

@@ -0,0 +1,77 @@
+module DiandianOAuth
+  class Response
+    attr_accessor :error, :meta, :response, :internal
+    def self.from_response response
+      response_json = response.parsed
+      result = Response.new
+      result.internal = response
+      result.error = response_json['error']
+      return result if result.error
+      result.meta = response_json['meta']
+      result.response = response_json['response']
+      result
+    end
+
+    def validate
+      !error && meta['status'] == 200
+    end
+    alias_method :success?, :validate
+
+    # throw exception when an error occurs
+    def validate!
+      puts "error: '#{self.inspect}'"
+      unless self.validate
+        if error
+          exception =
+              case error[:error]
+                when 'invalid_request' then DiandianOAuth::InvalidateRequestError
+                when 'unauthorized_client' then DiandianOAuth::UnauthorizedClientError
+                when 'access_denied' then DiandianOAuth::AccessDeniedError
+                when 'unsupported_response_type' then DiandianOAuth::UnsupportedResponseTypeError
+                when 'invalid_scope' then DiandianOAuth::InvalidScopeError
+                when 'server_error' then DiandianOAuth::ServerError
+                else APIError
+              end
+          raise exception
+        else
+          exception =
+              case meta[:status]
+                when 400000 then DiandianOAuth::ClientError
+                when 400001 then DiandianOAuth::ParameterError
+                when 400010 then DiandianOAuth::EmailError
+                when 400011 then DiandianOAuth::PasswordError
+                when 400012 then DiandianOAuth::EccentricAccountError
+                when 400013 then DiandianOAuth::EmailFormatError
+                when 400014 then DiandianOAuth::PasswordFormatError
+                when 400015 then DiandianOAuth::EmailExistsError
+                when 400020 then DiandianOAuth::BindingFailError
+                when 400030 then DiandianOAuth::FollowError
+                when 400031 then DiandianOAuth::UnfollowError
+                when 400040 then DiandianOAuth::IllegalContentError
+                when 400050 then DiandianOAuth::InboxContentCannotBeEmptyError
+                when 400051 then DiandianOAuth::InboxContentTooLongError
+                when 400052 then DiandianOAuth::InboxClosedError
+                when 400053 then DiandianOAuth::CannotSendToOwnBlogError
+                when 400060 then DiandianOAuth::OperationTooFastError
+                when 400070 then DiandianOAuth::BlogClosedError
+                when 400080 then DiandianOAuth::VerifyCodeExpiredError
+                when 400081 then DiandianOAuth::VerifyCodeWrongError
+                when 401000 then DiandianOAuth::UnauthorizedError
+                when 403000 then DiandianOAuth::VisitForbiddenError
+                when 403001 then DiandianOAuth::BlogManagerRequiredError
+                when 404002 then DiandianOAuth::BlogNotFoundError
+                when 404003 then DiandianOAuth::ContentNotFoundError
+                when 404004 then DiandianOAuth::UserNotFoundError
+                when 500000 then DiandianOAuth::InternalServerError
+                when 500001 then DiandianOAuth::PostTypeError
+                when 500002 then DiandianOAuth::InboxError
+                when 503001 then DiandianOAuth::UpgradingError
+                else DiandianOAuth::APIError
+              end
+          raise exception
+        end
+      end
+    end
+
+  end
+end

data/lib/diandian_oauth/models/response_meta.rb

@@ -0,0 +1,61 @@
+module DiandianOAuth
+  class ResponseMeta
+    attr_accessor :status, :message
+    def self.from_response response_json
+      meta = response_json['meta']
+      response_meta = ResponseMeta.new
+      response_meta.status = meta['status']
+      response_meta.message = meta['msg']
+      response_meta
+    end
+
+    def success?
+      self.validate
+    end
+
+    def validate
+      self.status == 200
+    end
+
+    def validate!
+      if !self.validate
+        exception =
+            case self.status
+              when 400000 then DiandianOAuth::ClientError
+              when 400001 then DiandianOAuth::ParameterError
+              when 400010 then DiandianOAuth::EmailError
+              when 400011 then DiandianOAuth::PasswordError
+              when 400012 then DiandianOAuth::EccentricAccountError
+              when 400013 then DiandianOAuth::EmailFormatError
+              when 400014 then DiandianOAuth::PasswordFormatError
+              when 400015 then DiandianOAuth::EmailExistsError
+              when 400020 then DiandianOAuth::BindingFailError
+              when 400030 then DiandianOAuth::FollowError
+              when 400031 then DiandianOAuth::UnfollowError
+              when 400040 then DiandianOAuth::IllegalContentError
+              when 400050 then DiandianOAuth::InboxContentCannotBeEmptyError
+              when 400051 then DiandianOAuth::InboxContentTooLongError
+              when 400052 then DiandianOAuth::InboxClosedError
+              when 400053 then DiandianOAuth::CannotSendToOwnBlogError
+              when 400060 then DiandianOAuth::OperationTooFastError
+              when 400070 then DiandianOAuth::BlogClosedError
+              when 400080 then DiandianOAuth::VerifyCodeExpiredError
+              when 400081 then DiandianOAuth::VerifyCodeWrongError
+              when 401000 then DiandianOAuth::UnauthorizedError
+              when 403000 then DiandianOAuth::VisitForbiddenError
+              when 403001 then DiandianOAuth::BlogManagerRequiredError
+              when 404002 then DiandianOAuth::BlogNotFoundError
+              when 404003 then DiandianOAuth::ContentNotFoundError
+              when 404004 then DiandianOAuth::UserNotFoundError
+              when 500000 then DiandianOAuth::InternalServerError
+              when 500001 then DiandianOAuth::PostTypeError
+              when 500002 then DiandianOAuth::InboxError
+              when 503001 then DiandianOAuth::UpgradingError
+              else DiandianOAuth::APIError
+            end
+        raise exception, self.message
+      end
+      self
+    end
+  end
+end

data/test/diandian_oauth/authorize_test.rb

@@ -1,8 +1,8 @@
 require File.join( File.dirname(__FILE__), 'test_helper')
 
 class AuthorizeTest < ActiveSupport::TestCase
-  CLIENT_ID="3zgJwues92"
-  CLIENT_SECRET="1rxLZr5R4sweGUATGig25VBc1ka1xDEpkIqJ"
+  CLIENT_ID="fr2ejCbPrO"
+  CLIENT_SECRET="C5Cgprqe3DC674vdnaQlujko9ItuSAOB24qa"
 
   test 'authorize_url' do
     assert_nothing_raised do
@@ -12,11 +12,12 @@ class AuthorizeTest < ActiveSupport::TestCase
   end
 
   test 'access_token' do
-    code = '7KhUBh'
+    code = 'dJGgxE'
     unless code.empty?
       assert_nothing_raised do
-        client = DiandianOAuth::Client.new CLIENT_ID, CLIENT_SECRET, :redirect_uri => 'http://example.com/callback'
+        client = DiandianOAuth::Client.new CLIENT_ID, CLIENT_SECRET, :redirect_uri => 'http://example.com/users/auth/diandian/callback'
         access_token = client.access_token code
+        p access_token
       end
     end
   end

data/test/diandian_oauth/interface_test.rb

@@ -1,14 +1,16 @@
 require File.join( File.dirname(__FILE__), 'test_helper')
 
+require 'faraday/request/diandian_multipart'
+
 class InterfaceTest < ActiveSupport::TestCase
-  CLIENT_ID="3zgJwues92"
-  CLIENT_SECRET="1rxLZr5R4sweGUATGig25VBc1ka1xDEpkIqJ"
+  CLIENT_ID="fr2ejCbPrO"
+  CLIENT_SECRET="C5Cgprqe3DC674vdnaQlujko9ItuSAOB24qa"
   ACCESS_TOKEN = {
-      :access_token => 'adbab585-ea39-47e0-87ce-da7700fd3d9b',
-      :refresh_token => "79852349-5f2e-4e3b-93b8-845e239e61ff",
+      :access_token => '92eb54ba-4be0-4a75-ae2a-d185d0a0f751',
+      :refresh_token => "fa522c29-fc69-4d45-ab59-b9e26b9e5ed5",
       :token_type => "bearer",
-      :expires_in => 604799,
-      :expires_at => 1344317317,
+      :expires_in => 3406,
+      :expires_at => 1344410022,
       :scope => "write read",
       :uid => "11449"
   }
@@ -22,10 +24,46 @@ class InterfaceTest < ActiveSupport::TestCase
   test 'user_info' do
     client = self.client
     client.access_token= ACCESS_TOKEN
-    begin
-      p client.user_info
-    rescue DiandianOAuth::API::TokenExpiredException => e
-    end
+    p client.user_info
+  end
+
+  test 'user_info!' do
+    client = self.client
+    client.access_token = ACCESS_TOKEN.merge(:expires_at => Time.now.to_i - 1.day.to_i)
+    puts "expired?: '#{client.access_token.expired?}'"
+    p client.user_info!
+  end
+
+  test 'create_post' do
+    client = self.client
+    client.access_token = ACCESS_TOKEN
+    p client.create_post  :blogCName => 'secretworry.diandian.com',
+      :type => 'text',
+      :state => 'published',
+      :title => 'Hello from diandian ruby client'
+  end
+
+  test 'create_photo_post' do
+    client = self.client
+    client.access_token = ACCESS_TOKEN
+    Faraday::Request.register_middleware :diandian_multipart => Faraday::Request::DiandianMultipart
+    p client.user_info!
+    p client.create_post! :blogCName => 'tree-hollow.diandian.com',
+      :type =>  'photo',
+      :state => 'published',
+      :data => [Faraday::UploadIO.new('/Users/siyudu/Pictures/test/blue_700_342.jpg', 'image/jpeg'), Faraday::UploadIO.new('/Users/siyudu/Pictures/test/white_700_342.jpg', 'image/jpeg')]
+  end
+
+  test 'submissions' do
+    client = self.client
+    client.access_token = ACCESS_TOKEN
+    p client.submissions :blogCName => 'secretworry.diandian.com'
+  end
+
+  test 'delete_post' do
+    client = self.client
+    client.access_token = ACCESS_TOKEN
+    p client.delete_post :blogCName => 'secretworry.diandian.com', :id => '3fdc4740-dcce-11e1-a2d7-782bcb43b268'
   end
 
   test 'posts' do
@@ -35,6 +73,9 @@ class InterfaceTest < ActiveSupport::TestCase
   end
 
   def client
+    DiandianOAuth::Client.token_refreshed (lambda{|client, token|
+      p "token_refreshed: '#{token}'"
+    })
     @client ||= DiandianOAuth::Client.new CLIENT_ID, CLIENT_SECRET, :redirect_uri => 'http://example.com/callback'
   end
 end

metadata

@@ -2,7 +2,7 @@
 name: diandian-oauth
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.3
+  version: 0.1.1
 platform: ruby
 authors: 
 - Rainer Du
@@ -69,7 +69,10 @@ files:
 - lib/diandian_oauth/api.rb
 - lib/diandian_oauth/api/interface.rb
 - lib/diandian_oauth/client.rb
+- lib/diandian_oauth/client/callbacks.rb
 - lib/diandian_oauth/exceptions.rb
+- lib/diandian_oauth/models/response.rb
+- lib/diandian_oauth/models/response_meta.rb
 - test/diandian_oauth/api_test.rb
 - test/diandian_oauth/authorize_test.rb
 - test/diandian_oauth/interface_test.rb