curate_tumblr 1.0.3

data/lib/curate_tumblr/publish/follow.rb

@@ -0,0 +1,62 @@
+module CurateTumblr
+  module Publish
+    module Follow
+
+      attr_accessor :all_tofollow_urls
+
+      def init_follow!( hash_config={} )
+        @all_tofollow_urls = Set.new
+      end
+
+      def follow_url( url )
+        tumblr_url = CurateTumblr::Tumblr::ExtractLinks.get_tumblr_url( url )
+        client_follow( tumblr_url )
+      end
+
+      def add_tofollow_url( url )
+        raise "no tumblr url" if !url
+        url = CurateTumblr::Tumblr::ExtractLinks.get_tumblr_url( url ) if !CurateTumblr::Tumblr::ExtractLinks.tumblr_url?( url )
+        return false if !url || !CurateTumblr::Tumblr::ExtractLinks.tumblr_url?( url )
+        tumblr_url = url.dup
+        CurateTumblr.format_tumblr_url!( tumblr_url )
+        @all_tofollow_urls << tumblr_url
+        @all_tofollow_urls.count
+      end      
+
+    private
+
+      def add_tofollow_tumblr_links_from_caption( caption, source=false )
+        tumblr_links = CurateTumblr::Tumblr::ExtractLinks.get_tumblr_urls_from_text( caption )
+        tumblr_links.each { |link| add_tofollow_url( link ) if !source || source != link  }
+        tumblr_links
+      end
+
+      def add_tofollow_source_from_hash_post( hash_post )
+        source = CurateTumblr.get_source_from_hash_post( hash_post )
+        return false if !source
+        add_tofollow_url( source )
+      end          
+      
+      def add_tofollow_from_post( tumblr_url, hash_post )
+        raise "no tumblr url" if !tumblr_url
+        if !add_tofollow_url( tumblr_url )
+          return_error( __method__, "can't follow tumblr url", { tumblr_url: tumblr_url, hash_post: CurateTumblr.get_summary_hash_post( hash_post ) } )
+        end         
+        add_tofollow_source_from_hash_post( hash_post )
+        add_tofollow_link_url_from_hash_post( hash_post )
+        true
+      end   
+      
+      def add_tofollow_source_from_post_id( tumblr_url, post_id )
+        raise "no tumblr url" if !tumblr_url
+        add_tofollow_source_from_hash_post( get_hash_post( tumblr_url, post_id ) )        
+      end
+
+      def add_tofollow_link_url_from_hash_post( hash_post )
+        link_url = CurateTumblr.get_link_url_from_hash_post( hash_post )
+        return false if !link_url
+        add_tofollow_url( link_url )
+      end 
+    end
+	end
+end

data/lib/curate_tumblr/publish/post.rb

@@ -0,0 +1,21 @@
+module CurateTumblr
+  module Publish  
+    module Post
+
+      def init_post!( hash_config={} )
+      end
+ 
+      def post_photos( photos_paths, caption='' )
+        caption = caption + @infos_caption
+        photos_paths = [photos_paths] if photos_paths.is_a? String
+        CurateTumblr.check_paths_ar_photos( photos_paths )
+        client_post_photos( photos_paths, body )
+      end
+    
+      def post_text( title, body )
+        body = body + @infos_caption
+        client_post_text( title, body )        
+      end
+   end        
+  end
+end

data/lib/curate_tumblr/publish/reblog.rb

@@ -0,0 +1,86 @@
+module CurateTumblr
+  module Publish
+    module Reblog
+
+      def init_reblog!( hash_config={} )
+      end
+
+	    def reblog_and_extract( url )
+	      return false if @is_stop
+	      return false if !CurateTumblr::Tumblr::ExtractLinks.tumblr_url?( url )
+	      if !CurateTumblr::Tumblr::ExtractLinks.tumblr_post_url?( url ) 
+	        return reblog_and_add_tofollow_reblog_url( url ) if CurateTumblr::Tumblr::ExtractLinks.tumblr_reblog_url?( url )
+	        return add_tofollow_url( url ) 
+	      end
+	      reblog_and_toadd_tofollow_from_post_url( url )
+	    end    
+
+      private 
+    
+      # --- reblog ---
+ 
+      def reblog_and_add_tofollow_reblog_url( reblog_url )
+        post_id = CurateTumblr::Tumblr::ExtractLinks.get_post_id_from_reblog_url( reblog_url )
+        if !CurateTumblr.post_id_valid?( post_id )
+          return return_error( __method__, "post_id not valid", { post_id: post_id, reblog_url: reblog_url } ) 
+        end
+        reblog_key = CurateTumblr::Tumblr::ExtractLinks.get_reblog_key_from_reblog_url( reblog_url )
+        if !CurateTumblr.reblog_key_valid?( reblog_key )
+          return return_error( __method__, "reblog_key not valid", { reblog_key: reblog_key, post_id: post_id, reblog_url: reblog_url } ) 
+        end
+        new_post_id = reblog_post_key( post_id, reblog_key )  
+        add_tofollow_source_from_post_id( @tumblr_name, new_post_id )
+        new_post_id
+      end
+ 
+      def reblog_and_toadd_tofollow_from_post_url( post_url )
+        hash_url = CurateTumblr.get_hash_url_from_post_url( post_url )
+        if !CurateTumblr.hash_url_valid?( hash_url )
+          return return_error( __method__, "hash_url not valid", { hash_url: hash_url, post_url: post_url } ) 
+        end
+
+        reblog_and_add_tofollow_post_id( hash_url[:tumblr_url], hash_url[:post_id] )
+      end
+     
+      def reblog_and_add_tofollow_post_id( tumblr_url, post_id )
+        hash_post = get_hash_post( tumblr_url, post_id ) 
+        return false if !hash_post
+        id = reblog_from_hash_post( hash_post )
+        add_tofollow_from_post( tumblr_url, hash_post ) 
+        extract_links_caption_from_post( hash_post ) 
+        id
+      end
+  
+      def reblog_from_hash_post( hash_post )
+        post_id = hash_post["id"]
+        reblog_key = CurateTumblr.get_reblog_key_from_hash_post( hash_post )
+        return false if !reblog_key   
+        reblog_post_key( post_id, reblog_key )
+      end
+  
+      def reblog_post_key( post_id, reblog_key )
+        # @log_tumblr.debug "#{__method__} count=#{self.count} for #{self.max_posts}" if @is_debug
+        return false if !reblog_post?( post_id, reblog_key )
+        client_reblog( post_id, reblog_key )
+      end
+
+      def reblog_post?( post_id, reblog_key )
+        if !can_run?
+          @log_tumblr.debug "can't reblog #{post_id} because can't run" if @is_debug 
+          return false 
+        end
+        
+        if !CurateTumblr.post_id_valid?( post_id )
+          @log_tumblr.warn "#{__method__} post_id #{post_id} is not valid"
+          return false 
+        end
+        
+        if !CurateTumblr.reblog_key_valid?( reblog_key )
+          @log_tumblr.warn "#{__method__} reblog_key #{reblog_key} is not valid for post_id #{post_id}"
+          return false 
+        end
+        true        
+      end
+    end
+  end
+end

data/lib/curate_tumblr/render/render_follow.rb

@@ -0,0 +1,29 @@
+module CurateTumblr
+  module Render	
+    class RenderFollow < RenderLinks
+      def initialize( tumblr_name, directory='/home/tumblr' )
+	    	super( tumblr_name, directory )
+	    	@filename_links = @curator.get_filename_tofollow
+	    end
+
+      def render_link( link, new_links, links_errors )
+        @curator.client_follow( link ) 
+      end  
+
+      def get_max
+        @curator.max_followed
+      end      
+
+      def get_count
+        @curator.count_followed
+      end
+
+      private
+
+        def after_render
+          super
+          add_info_render( "followed #{@curator.count_followed} links in #{to_s}" )
+        end      
+    end
+  end    
+end

data/lib/curate_tumblr/render/render_links.rb

@@ -0,0 +1,132 @@
+module CurateTumblr
+  module Render
+    class RenderLinks
+      include Enumerable # links      
+
+      attr_accessor :links_to_render, :filename_links, :filename_errors, :is_stop
+      attr_reader :info_render
+            
+      class << self
+        def render( object_render, name, is_display_infos=true )
+          puts "\n#{name} begin at #{Time.now.strftime("%H:%m")} (max #{object_render.get_max})" if is_display_infos
+          object_render.render_links_from_file
+          puts "\n#{name} end at #{Time.now.strftime("%H:%m")}" if is_display_infos
+          puts "> #{object_render.info_render}" if is_display_infos
+          object_render
+        end
+      end
+
+      def initialize( tumblr_name, directory='/home/tumblr' )
+        @curator = Curator.new( tumblr_name, directory )
+        reboot!( false )
+        @filename_errors = @curator.get_filename_errors
+      end
+
+      def reboot!( is_init_curator=true )
+        @curator.init_tumblr! if is_init_curator
+        @links_to_render = Set.new 
+        @info_render = ""
+        @is_stop = @curator.is_stop
+      end
+
+      def add_links_to_render( links )
+        links = links.to_a if !links.is_a?( Array ) && !links.is_a?( Set )
+        links = Set.new( links ) if !links.is_a? Set
+        links = Set.new( links.to_a.shuffle )
+        @links_to_render += links
+      end  
+
+      def render_links_from_file
+        before_render
+        new_links = @links_to_render.dup
+        links_errors = Set.new
+
+        @links_to_render.each do |link|
+          break if check_if_stop
+          result = render_link( link.chomp, new_links, links_errors )          
+          links_errors << link.chomp if !result
+          new_links.delete( link )
+          after_render_link( link, result )
+        end     
+
+        @links_to_render = new_links        
+        after_render
+        add_links_errors_file( links_errors )
+        get_count
+      end  
+
+      def get_all_published_id
+        @curator.all_published_id
+      end
+
+      def get_count_all_requests_and_posts
+        @curator.count_all_requests_and_posts
+      end
+
+      def get_links_torender_from_file
+        CurateTumblr.get_ar_from_file( @filename_links )
+      end
+
+      def to_s
+        "#{@curator.state} #{@curator.tumblr_name} (#{@curator.count_all_requests_and_posts} total requests and posts)"
+      end
+
+      # --- methods to define in child ---
+
+      def render_link( link, new_links, links_errors )
+        raise "no render method"
+      end  
+
+      def get_max
+        raise "no max method"
+      end
+
+      def get_count
+        raise "no count method"
+      end
+
+      private
+
+        def check_if_stop
+          @is_stop = true if get_count >= get_max
+          @is_stop = @curator.is_stop if !@is_stop
+          @is_stop
+        end
+
+        def after_render_link( link, result )
+        end
+
+        def before_render
+          raise "no filename for links" if !@filename_links
+          CurateTumblr.backup_file( @filename_links )
+          add_links_to_render( get_links_torender_from_file )
+        end
+
+        def after_render
+          replace_links_torender_in_file( @links_to_render )
+        end
+
+        def replace_links_torender_in_file( new_links )
+          new_links = Set.new( new_links.to_a.shuffle )
+          File.open( @filename_links , "w+" ) { |file| file.puts( new_links.to_a ) }
+        end
+
+        def add_links_errors_file( links_errors )
+          File.open( @filename_errors, "a" ) { |file| file << "\n" + links_errors.to_a.join("\n")  }
+        end         
+
+        def empty_file_links_reblog
+          File.open( @filename_links, "w+" ) { }
+        end   
+
+        def add_links_errors_file( links_errors )
+          File.open( @filename_errors, "a" ) { |file| file << "\n" + links_errors.to_a.join("\n")  }
+        end         
+
+        def add_info_render( info )
+          @info_render = info
+          @curator.log_tumblr.info(info)
+        end 
+    end
+  end  
+end

data/lib/curate_tumblr/render/render_reblog.rb

@@ -0,0 +1,36 @@
+module CurateTumblr
+  module Render	
+    class RenderReblog < RenderLinks
+
+      class << self
+
+      end
+
+	    def initialize( tumblr_name, directory='/home/tumblr' )
+	    	super( tumblr_name, directory )
+	    	@filename_links = @curator.get_filename_links
+	    end
+
+      def render_link( link, new_links, links_errors )
+        @curator.reblog_and_extract( link ) 
+      end  
+
+      def get_max
+        @curator.max_reblogged
+      end      
+
+      def get_count
+        @curator.count_rebloged
+      end
+
+      private
+
+        def after_render
+          super
+          @curator.add_tofollow_tofile
+          @curator.add_externallinks_tofile
+          add_info_render( "reblogged #{@curator.count_rebloged} links in #{to_s}" )
+        end
+    end
+  end    
+end

data/lib/curate_tumblr/tumblr/client.rb

@@ -0,0 +1,347 @@
+module CurateTumblr
+  module Tumblr
+	 module Client
+	  HASH_CONFIG_CLIENT = "client"
+	  HASH_CONFIG_IS_RUNNING = "is_running"
+	  HASH_CONFIG_SLEEP_BEFORE_CLIENT = "sleep_before_client"
+	  HASH_CONFIG_SLEEP_BEFORE_CLIENT_MIN = "sleep_before_client_min"
+	  HASH_CONFIG_SLEEP_BEFORE_CLIENT_MAX = "sleep_before_client_max"
+	  HASH_CONFIG_SLEEP_BEFORE_FOLLOW_MIN = "sleep_before_follow_min"
+	  HASH_CONFIG_SLEEP_BEFORE_FOLLOW_MAX = "sleep_before_follow_max"
+	  HASH_CONFIG_MAX_REQUESTS_AND_POSTS = "max_requests_and_posts"
+	  HASH_CONFIG_MAX_POSTED = "max_posted"
+	  HASH_CONFIG_MAX_REBLOGGED = "max_reblogged"
+	  HASH_CONFIG_MAX_FOLLOWED = "max_followed"
+	  HASH_CONFIG_CLIENT_OAUTH = "oauth"
+	  HASH_CONFIG_CLIENT_OAUTH_CONSUMER_KEY = "consumer_key"
+	  HASH_CONFIG_CLIENT_OAUTH_CONSUMER_SECRET = "consumer_secret"	
+	  HASH_CONFIG_CLIENT_OAUTH_TOKEN = "token"
+	  HASH_CONFIG_CLIENT_OAUTH_TOKEN_SECRET = "token_secret"	
+
+		attr_accessor :client, :sleep_before_client, :sleep_before_client_min, :sleep_before_client_max, :sleep_before_follow_min, :sleep_before_follow_max,  
+			:max_requests_and_posts, :max_posted, :max_reblogged, :max_followed
+	 	attr_reader :all_published_id, :count_all_requests_and_posts, :count_continuous_bad_requests, :count_posted, :count_rebloged, :count_followed
+
+	 	class << self
+      def get_client_config_hash( oauth_consumer_key, oauth_consumer_secret, oauth_token, oauth_token_secret )
+        {
+          HASH_CONFIG_CLIENT => {
+	          HASH_CONFIG_CLIENT_OAUTH => {
+	            HASH_CONFIG_CLIENT_OAUTH_CONSUMER_KEY => oauth_consumer_key,
+	            HASH_CONFIG_CLIENT_OAUTH_CONSUMER_SECRET => oauth_consumer_secret, 
+	            HASH_CONFIG_CLIENT_OAUTH_TOKEN => oauth_token,
+	            HASH_CONFIG_CLIENT_OAUTH_TOKEN_SECRET => oauth_token_secret, 
+	          }
+	        }
+	      }
+      end
+
+      def get_string_yaml_from_client_config( hash_config )
+        hash_client_config = hash_config[HASH_CONFIG_CLIENT]
+        %Q{
+          #{HASH_CONFIG_CLIENT}:
+            #{HASH_CONFIG_CLIENT_OAUTH}:
+              #{HASH_CONFIG_CLIENT_OAUTH_CONSUMER_KEY}:        "#{hash_client_config[HASH_CONFIG_CLIENT_OAUTH][HASH_CONFIG_CLIENT_OAUTH_CONSUMER_KEY]}"
+              #{HASH_CONFIG_CLIENT_OAUTH_CONSUMER_SECRET}:     "#{hash_client_config[HASH_CONFIG_CLIENT_OAUTH][HASH_CONFIG_CLIENT_OAUTH_CONSUMER_SECRET]}"
+              #{HASH_CONFIG_CLIENT_OAUTH_TOKEN}:               "#{hash_client_config[HASH_CONFIG_CLIENT_OAUTH][HASH_CONFIG_CLIENT_OAUTH_TOKEN]}"
+              #{HASH_CONFIG_CLIENT_OAUTH_TOKEN_SECRET}:        "#{hash_client_config[HASH_CONFIG_CLIENT_OAUTH][HASH_CONFIG_CLIENT_OAUTH_TOKEN_SECRET]}"
+        }
+      end          
+
+	    def check_client_config_hash( hash_config )
+        hash_config.check_key( HASH_CONFIG_CLIENT )
+        hash_client_config = hash_config[HASH_CONFIG_CLIENT]
+        hash_client_config.check_key( HASH_CONFIG_CLIENT_OAUTH )
+        hash_client_config[HASH_CONFIG_CLIENT_OAUTH].check_key( HASH_CONFIG_CLIENT_OAUTH_CONSUMER_KEY )
+        hash_client_config[HASH_CONFIG_CLIENT_OAUTH].check_key( HASH_CONFIG_CLIENT_OAUTH_CONSUMER_SECRET )
+        hash_client_config[HASH_CONFIG_CLIENT_OAUTH].check_key( HASH_CONFIG_CLIENT_OAUTH_TOKEN )
+        hash_client_config[HASH_CONFIG_CLIENT_OAUTH].check_key( HASH_CONFIG_CLIENT_OAUTH_TOKEN_SECRET )
+	    end
+	 	end
+
+	 	# --- config ---
+
+	  def init_client!( hash_config={} )
+	    @all_published_id = Set.new
+			@count_all_requests_and_posts = 0
+		  @count_continuous_bad_requests = 0
+			@count_posted = 0
+			@count_rebloged = 0
+			@count_followed = 0
+			@sleep_before_client = false
+			@sleep_before_follow_min = false
+			@max_requests_and_posts = 50
+			@max_posted = 30
+			@max_reblogged = @max_posted
+			@max_followed = @max_posted
+    	config_client( hash_config ) if !hash_config.empty?
+	  end
+
+	  def config_client( hash_config )
+	    hash_client = hash_config[HASH_CONFIG_CLIENT]
+	    config_oauth( hash_client[HASH_CONFIG_CLIENT_OAUTH] )
+	    stop_it!("'#{HASH_CONFIG_IS_RUNNING}' is False in config") if hash_client.has_key?( HASH_CONFIG_IS_RUNNING ) && !hash_client[HASH_CONFIG_IS_RUNNING]
+	    @sleep_before_client = hash_client[HASH_CONFIG_SLEEP_BEFORE_CLIENT] if hash_client.has_key?( HASH_CONFIG_SLEEP_BEFORE_CLIENT )
+	    @sleep_before_client_min = hash_client[HASH_CONFIG_SLEEP_BEFORE_CLIENT_MIN] if hash_client.has_key?( HASH_CONFIG_SLEEP_BEFORE_CLIENT_MIN )
+	    @sleep_before_client_max = hash_client[HASH_CONFIG_SLEEP_BEFORE_CLIENT_MAX] if hash_client.has_key?( HASH_CONFIG_SLEEP_BEFORE_CLIENT_MAX )
+	    @sleep_before_follow_min = hash_client[HASH_CONFIG_SLEEP_BEFORE_FOLLOW_MIN] if hash_client.has_key?( HASH_CONFIG_SLEEP_BEFORE_FOLLOW_MIN )
+	    @sleep_before_follow_max = hash_client[HASH_CONFIG_SLEEP_BEFORE_FOLLOW_MAX] if hash_client.has_key?( HASH_CONFIG_SLEEP_BEFORE_FOLLOW_MAX )
+	    @max_requests_and_posts = hash_client[HASH_CONFIG_MAX_REQUESTS_AND_POSTS] if hash_client.has_key?( HASH_CONFIG_MAX_REQUESTS_AND_POSTS )
+	    @max_posted = hash_client[HASH_CONFIG_MAX_POSTED] if hash_client.has_key?( HASH_CONFIG_MAX_POSTED )
+	    @max_reblogged = hash_client[HASH_CONFIG_MAX_REBLOGGED] if hash_client.has_key?( HASH_CONFIG_MAX_REBLOGGED )
+	    @max_followed = hash_client[HASH_CONFIG_MAX_FOLLOWED] if hash_client.has_key?( HASH_CONFIG_MAX_FOLLOWED )
+	  end
+
+	  def check_client_config
+	  end
+
+	 	def config_oauth( hash_oauth ) 
+		  ::Tumblr.configure do |config|
+			  config.consumer_key = hash_oauth[HASH_CONFIG_CLIENT_OAUTH_CONSUMER_KEY]
+			  config.consumer_secret = hash_oauth[HASH_CONFIG_CLIENT_OAUTH_CONSUMER_SECRET]
+			  config.oauth_token = hash_oauth[HASH_CONFIG_CLIENT_OAUTH_TOKEN]
+			  config.oauth_token_secret = hash_oauth[HASH_CONFIG_CLIENT_OAUTH_TOKEN_SECRET]
+			end
+			@client = ::Tumblr::Client.new 		
+	  end
+
+	  # --- request and post ---
+	  
+	  def display_url_post( tumblr_url, post_id, is_short=false )
+	    display_hash_post( get_hash_post(tumblr_url, post_id), is_short )
+	  end
+    
+	  # tumblr_url must be xxxx.tumblr.com
+	  # @todo check valid tumblr_url (not xxx.tumblr.compost or xxx.tumblr.com/post...)
+	  def get_hash_post( tumblr_url, post_id )
+	    CurateTumblr.format_tumblr_url!( tumblr_url )
+	    tumblr_url = get_tumblr_domain if tumblr_url.empty?
+
+	    hash_posts_multiple = client_get_posts( tumblr_url, post_id )
+	    if !CurateTumblr.hash_multiple_posts_valid?( hash_posts_multiple )
+	      log_tumblr.error "#{__method__} hash_posts_multiple #{hash_posts_multiple} are not valid for tumblr_url=#{tumblr_url} and post_id=#{post_id}"
+	      return false 
+	    end
+      if hash_posts_multiple['posts'].count != 1
+	      log_tumblr.error "#{__method__} hash_posts_multiple #{hash_posts_multiple} have not one element for tumblr_url=#{tumblr_url} and post_id=#{post_id}"
+	      return false 
+	    end
+	    
+      hash_post = hash_posts_multiple['posts'][0]
+      if !CurateTumblr.hash_post_valid?( hash_post )
+	      log_tumblr.error "#{__method__} hash_post #{hash_post} is not valid for tumblr_url=#{tumblr_url} and post_id=#{post_id}"
+	      return false 
+	    end
+	    hash_post
+	  end   
+
+	  def get_post_global_options
+	    if !@state
+	      @state = POST_STATE_PUBLISH 
+	      log_tumblr.warn( "state was empty, so posts will be published" )
+	    end
+	    options = { state: @state }
+	    options.merge!( { tags: @infos_tags } ) if !@infos_tags.empty?  
+	    options
+	  end  
+	      
+	  def get_post_text_options( title, body )
+	    { title: title, body: body }.merge( get_post_global_options )
+	  end  
+	    
+	  def get_post_photos_options( photos_paths, caption='' )
+	    { data: photos_paths, caption: caption }.merge( get_post_global_options )
+	  end 
+	            
+	  def get_reblog_options( post_id, reblog_key )
+	    { id: post_id, reblog_key: reblog_key, comment: @infos_caption }.merge( get_post_global_options )
+	  end 
+
+	  def get_id_post_if_ok( hash_id )
+	    return false if !status_result( hash_id ) 
+	    id = CurateTumblr.get_id_from_direct_post( hash_id )
+	    if !CurateTumblr.post_id_valid?( id )
+	      return return_error( __method__, "id is not valid", { id: id } )
+	    end   
+	    id
+	  end
+
+	  def sleep_before( seconds=false )
+	    seconds = @sleep_before_client if !seconds
+	    seconds = CurateTumblr.get_random_sleep( @sleep_before_client_min, @sleep_before_client_max ) if !seconds
+	    sleep_print( seconds )
+	  end
+	    
+	  def delete_post!( id ) 
+	    client_delete_post!( id )
+	    @ar_posted_id.delete( id )
+	    true
+	  end
+
+    # --- tumblr api ---
+
+	  def get_queue( limit='' )
+	    @client.queue( get_tumblr_domain, {limit: limit} )
+	  end
+
+    def client_post_text( title, body )
+      return false if !before_post
+      id = get_id_post_if_ok( @client.text( get_tumblr_domain, get_post_text_options( title, body ) ) )
+      after_posted( id )
+    end
+       
+    def client_post_photos( photos_paths, caption='' )
+      return false if !before_post
+      id = get_id_post_if_ok( @client.photo( get_tumblr_domain, get_post_photos_options( photos_paths, caption ) ) ) 
+      after_posted( id ) 
+    end   
+      
+    def client_reblog( post_id, reblog_key )
+      return false if !before_reblog
+      id = get_id_post_if_ok( @client.reblog( get_tumblr_domain, get_reblog_options( post_id, reblog_key ) ) )        
+      after_rebloged( id )
+    end
+      
+    def client_follow( tumblr_url )
+      return false if !before_follow
+      result = status_result( @client.follow( tumblr_url ) )
+      after_followed( result )
+    end  
+      
+    def client_delete_post!( id )
+      return false if !before_client( false )        
+      result = @client.delete(get_tumblr_domain, id)
+      after_deleted( result, id )
+    end     
+
+    def client_get_posts( tumblr_url, post_id )
+      return false if !before_client( false )    
+      result = @client.posts( tumblr_url, { :id => post_id } )
+      after_get_posts( result )
+    end
+
+    # --- manage tumblr errors ---
+
+	  def status_result( hash_status, is_display=true, is_log=true )
+	    status_ok = get_status_if_ok( hash_status )
+	    if status_ok
+	      @count_continuous_bad_requests = 0 
+	      return status_ok 
+	    end
+	    return bad_request( is_display, is_log ) if CurateTumblr.hash_status_bad_request?( hash_status )
+	    return rate_limit_exceeded( is_display, is_log ) if CurateTumblr.hash_status_rate_limit?( hash_status )
+	    log_tumblr.error( "bad status result #{hash_status}" )
+	    false
+		end
+
+		def get_status_if_ok( hash_status )
+			return hash_status if !hash_status.is_a? Hash
+		  return hash_status if !hash_status.has_key?( "status" )
+		  return true if CurateTumblr.hash_status_ok?( hash_status )
+		  false
+		end      
+
+	  def rate_limit_exceeded( is_display=true, is_log=true )
+	    stop_and_alert( "Tumblr Rate Limit Exceeded, better wait one hour", is_display, is_log )
+	    false
+		end    
+
+	  def bad_request( is_display=true, is_log=true )
+	    @count_continuous_bad_requests += 1
+	    if @count_continuous_bad_requests >= COUNT_ALERT_IF_TOO_MUCH_BAD_REQUESTS
+	      message = "Too much (#{@count_continuous_bad_requests}) bad requests (perhaps the Tumblr queue is full)"
+	      stop_and_alert( message, is_display, is_log ) 
+	    end
+	    false
+		end  
+
+		private
+
+		  def sleep_print( seconds )
+		    seconds = 1 if seconds <= 0 || !seconds
+		    print DISPLAY_SLEEP_BEFORE if !DISPLAY_SLEEP_BEFORE.empty?
+		    print seconds
+		    sleep( seconds ) 
+		    print DISPLAY_SLEEP_AFTER if !DISPLAY_SLEEP_AFTER.empty?
+		  end		
+
+		  def before_client( is_add_count=true )
+		    config_from_yaml
+				stop_it!("max (#{@count_all_requests_and_posts}) requests and posts") if @count_all_requests_and_posts >= @max_requests_and_posts
+		    return false if !can_run?
+		    sleep_before( @sleep_before_client )
+		    @count_all_requests_and_posts += 1 if is_add_count
+		    true
+		  end    
+
+		  def before_post
+		    return false if !before_client
+		    if @count_posted >= @max_posted
+		      log_tumblr.warn( "posted maximum (#{@max_posted})")
+		      return false
+		    end 
+		    true
+		  end
+
+		  def before_reblog
+		    return false if !before_client
+		    if @count_rebloged >= @max_reblogged
+		      log_tumblr.warn( "reblogged maximum (#{@max_reblogged})")
+		      return false
+		    end 
+		    true
+		  end	
+
+		  def before_follow
+		    return false if !before_client
+		    if @count_followed >= @max_followed
+		      log_tumblr.warn( "followed maximum (#{@max_followed})")
+		      return false
+		    end 
+		    if @sleep_before_follow_min
+	        sleep_print( CurateTumblr.get_random_sleep( @sleep_before_follow_min, @sleep_before_follow_max ) )
+	      end
+		    true
+		  end	
+
+			def after_published( id )
+				all_published_id << id
+				id
+			end
+
+			def after_posted( id )
+			  return id if !id
+				@count_posted += 1
+		    print DISPLAY_TUMBLR_POST if id && !DISPLAY_TUMBLR_POST.empty?
+				after_published( id )
+			end
+
+			def after_rebloged( id )
+			  return id if !id
+				@count_rebloged += 1
+			  print " "+@count_rebloged.to_s + DISPLAY_TUMBLR_REBLOG + " " if !DISPLAY_TUMBLR_REBLOG.empty?
+				after_published( id )
+			end	
+
+			def after_followed( result )
+			  return result if !result
+				@count_followed += 1
+				print " " + @count_followed.to_s + DISPLAY_TUMBLR_FOLLOW + " " if !DISPLAY_TUMBLR_FOLLOW.empty?
+				result
+			end		
+
+			def after_deleted( result, id )
+			  return result if !result
+		    print " " + DISPLAY_TUMBLR_DELETE + " " if !DISPLAY_TUMBLR_DELETE.empty?
+		    all_published_id.delete( id )
+				result
+			end	
+
+			def after_get_posts( result )
+			  return result if !result
+		    print " " + DISPLAY_TUMBLR_GETPOSTS + " " if !DISPLAY_TUMBLR_GETPOSTS.empty?
+		    result
+			end
+    end
+	end
+end