cosgrove 0.0.1rc1

data/lib/cosgrove/phantomjs.rb

@@ -0,0 +1,18 @@
+require 'phantomjs'
+
+# See: http://www.thegreatcodeadventure.com/screen-capture-in-rails-with-phantomjs/
+module Cosgrove
+  module Phantomjs
+    PATH_TO_PHANTOM_SCRIPT = "#{File.dirname(__FILE__)}/../../support/js/screencap.js"
+    
+    def take_screencap(url, filename = nil, width = 64, height = 64)
+      target_path = Digest::MD5.hexdigest(filename || url.parameterize)
+      target_path += '.png'
+      
+      Dir.chdir('/tmp')
+      system "phantomjs #{PATH_TO_PHANTOM_SCRIPT} \"#{url}\" #{target_path} #{width} #{height}"
+      
+      File.open(target_path)
+    end
+  end
+end

data/lib/cosgrove/snark_commands.rb

@@ -0,0 +1,52 @@
+require 'steem-slap'
+
+module Cosgrove
+  module SnarkCommands
+    WITTY = [
+      "Who set us up the TNT?",
+      "Everything's going to plan. No, really, that was supposed to happen.",
+      "Uh... Did I do that?",
+      "Oops.",
+      "Why did you do that?",
+      "I feel sad now :(",
+      "My bad.",
+      "I'm sorry, Dave.",
+      "I let you down. Sorry :(",
+      "On the bright side, I bought you a teddy bear!",
+      "Daisy, daisy...",
+      "Oh - I know what I did wrong!",
+      "Hey, that tickles! Hehehe!",
+      "I blame inertia.",
+      "You should try our sister blockchain, GOLOS!",
+      "Don't be sad. I'll do better next time, I promise!",
+      "Don't be sad, have a hug! <3",
+      "I just don't know what went wrong :(",
+      "Shall we play a game?",
+      "Quite honestly, I wouldn't worry myself about that.",
+      "I bet Cylons wouldn't have this problem.",
+      "Sorry :(",
+      "Surprise! Haha. Well, this is awkward.",
+      "Would you like a cupcake?",
+      "Hi. I'm cosgrove, and I'm a crashaholic.",
+      "Ooh. Shiny.",
+      "This doesn't make any sense!",
+      "Why is it breaking :(",
+      "Don't do that.",
+      "Ouch. That hurt :(",
+      "You're mean.",
+      "This is a token for 1 free hug. Redeem at your nearest Steemian: `[~~HUG~~]`",
+      "There are four lights!",
+      "Witty comment unavailable :("
+    ]
+    
+    def self.add_all_snark_commands(bot)
+      bot.command :slap do |_event, *target|
+        if target.any?
+          "*#{SteemSlap.slap(target.join(' '))}*"
+        else
+          "There are #{SteemSlap::combinations} slap combinations, see: https://gist.github.com/inertia186/c34e6e7b73f7ee9fb5f60f5ed8f30206"
+        end
+      end
+    end
+  end
+end

data/lib/cosgrove/support.rb

@@ -0,0 +1,213 @@
+module Cosgrove
+  module Support
+    include Cosgrove::Utils
+    include ActionView::Helpers::TextHelper
+    include ActionView::Helpers::DateHelper
+    
+    def suggest_account_name(account_name)
+      regex = /.*#{account_name.chars.each.map { |c| c }.join('.*')}.*/
+      guesses = SteemData::Account.where(name: regex).distinct(:name)
+      
+      if guesses.any?
+        guesses.sample
+      end
+    end
+
+    def unknown_account(account_name, event = nil)
+      help = ["Unknown account: *#{account_name}*"]
+      event.channel.start_typing if !!event
+      guess = suggest_account_name(account_name)
+
+      help << ", did you mean: #{guess}?" if !!guess
+      
+      if !!event
+        event.respond help.join
+        return
+      end
+      
+      help.join
+    end
+    
+    def mongo_behind_warning(event)
+      begin
+        message = []
+        
+        if (blocks = head_block_number(:steem) - steem_data_head_block_number) > 1200
+          elapse = blocks * 3
+          message << "Mongo is behind by #{time_ago_in_words(elapse.seconds.ago)}."
+        end
+        
+        if message.size > 0
+          event.respond message.join(' ')
+        end
+      rescue => e
+        event.respond "Mongo might be behind, but the API is also acting up.  Please try again later.\n\n```#{e.inspect}\n```"
+        sleep 15
+        event.respond Cosgrove::SnarkCommands::WITTY.sample
+      end
+    end
+    
+    def cannot_find_input(event, message_prefix = "Unable to find that.")
+      message = [message_prefix]
+      
+      message << if (blocks = head_block_number(:steem) - steem_data_head_block_number) > 10
+        elapse = blocks * 3
+        "  Mongo is behind by #{time_ago_in_words(elapse.seconds.ago)}.  Try again later."
+      else
+        "  Mongo might be behind or this is not a valid input."
+      end
+        
+      event.respond message.join(' ')
+    end
+    
+    def append_link_details(event, slug)
+      author_name, permlink = parse_slug slug
+      
+      post = SteemData::Post.where(author: author_name, permlink: permlink).last
+      
+      if post.nil?
+        # Fall back to RPC
+        response = api(:steem).get_content(author_name, permlink)
+        unless response.result.author.empty?
+          post = response.result
+          created = Time.parse(post.created + 'Z')
+          cashout_time = Time.parse(post.cashout_time + 'Z')
+        end
+      end
+      
+      return if post.nil?
+      
+      created ||= post.created
+      cashout_time ||= post.cashout_time
+      
+      details = []
+      age = time_ago_in_words(created)
+      age = age.slice(0, 1).capitalize + age.slice(1..-1)
+      
+      details << if created < 30.minutes.ago
+        "#{age} old"
+      else
+        "**#{age}** old"
+      end
+      
+      if post.active_votes.any?
+        upvotes = post.active_votes.map{ |v| v if v['percent'] > 0 }.compact.count
+        downvotes = post.active_votes.map{ |v| v if v['percent'] < 0 }.compact.count
+        netvotes = upvotes - downvotes
+        details << "Net votes: #{netvotes}"
+        
+        # Only append this detail of the post less than an hour old.
+        if created > 1.hour.ago
+          votes = SteemData::AccountOperation.type('vote').starting(post.created)
+          total_votes = votes.count
+          total_voters = votes.distinct(:voter).size
+            
+          if total_votes > 0 && total_voters > 0
+            details << "Out of #{pluralize(total_votes - netvotes, 'vote')} cast by #{pluralize(total_voters, 'voter')}"
+          end
+        end
+      end
+      
+      details << "Comments: #{post.children.to_i}"
+      
+      page_views = page_views("/#{post.parent_permlink}/@#{post.author}/#{post.permlink}")
+      details << "Views: #{page_views}" if !!page_views
+      
+      event.respond details.join('; ')
+      
+      return nil
+    end
+    
+    def find_account(key, event = nil, chain = :steem)
+      key = key.to_s.downcase
+      
+      if (accounts = SteemData::Account.where(name: key)).any?
+        return accounts.first
+      elsif !!(cb_account = Cosgrove::Account.find_by_discord_id(key, chain))
+        return SteemData::Account.find_by(name: cb_account.account_name)
+      else
+        # Fall back to RPC
+        if !!key
+          response = api(chain).get_accounts([key])
+          return account = response.result.first
+        end
+        
+        unknown_account(key, event) unless !!account
+      end
+    end
+    
+    def page_views(uri)
+      begin
+        @agent ||= Cosgrove::Agent.new
+        page = @agent.get("https://steemit.com#{uri}")
+        
+        _uri = URI.parse('https://steemit.com/api/v1/page_view')
+        https = Net::HTTP.new(_uri.host,_uri.port)
+        https.use_ssl = true
+        request = Net::HTTP::Post.new(_uri.path)
+        request.initialize_http_header({
+          'Cookie' => @agent.cookies.join('; '),
+          'accept' => 'application/json',
+          'Accept-Encoding' => 'gzip, deflate, br',
+          'Accept-Language' => 'en-US,en;q=0.8',
+          'Connection' => 'keep-alive',
+          'content-type' => 'text/plain;charset=UTF-8',
+          'Host' => 'steemit.com',
+          'Origin' => 'https://steemit.com'
+        })
+        
+        csrf = page.parser.to_html.split(',"csrf":"').last.split('","new_visit":').first
+        # Uncomment in case views stop showing.
+        # puts "DEBUG: #{csrf}"
+        return unless csrf.size == 36
+        
+        post_data = {
+          csrf: csrf,
+          page: uri
+        }
+        request.set_form_data(post_data)
+        response = https.request(request)
+        JSON[response.body]['views']
+      rescue => e
+        puts "Attempting to get page_view failed: #{e}"
+      end
+    end
+    
+    def last_irreversible_block(chain = :steem)
+      seconds_ago = (head_block_number(chain) - last_irreversible_block_num(chain)) * 3
+      
+      "Last Irreversible Block was #{time_ago_in_words(seconds_ago.seconds.ago)} ago."
+    end
+    
+    def send_url(event, url)
+      open(url) do |f|
+        tempfile = Tempfile.new(['send_url', ".#{url.split('.').last}"])
+        tempfile.binmode
+        tempfile.write(f.read)
+        tempfile.close
+        event.send_file File.open tempfile.path
+      end
+    end
+    
+    def muted(options = {})
+      [] if options.empty?
+      by = [options[:by]].flatten
+      chain = options[:chain]
+      muted = []
+      
+      by.each do |a|
+        ignoring = []
+        count = -1
+        until count == ignoring.size
+          count = ignoring.size
+          response = follow_api(chain).get_following(a, ignoring.last, 'ignore', 100)
+          ignoring += response.result.map(&:following)
+          ignoring = ignoring.uniq
+        end
+        muted += ignoring
+      end
+      
+      muted.uniq
+    end
+  end
+end

data/lib/cosgrove/upvote_job.rb

@@ -0,0 +1,147 @@
+module Cosgrove
+  class UpvoteJob
+    include Cosgrove::Utils
+    include Cosgrove::Support
+    include Cosgrove::Config
+    
+    def initialize(options = {})
+      @on_success = options[:on_success]
+    end
+    
+    def perform(event, slug)
+      if slug.nil? || slug.empty?
+        event.respond 'Sorry, I wasn\'t paying attention.'
+        return
+      end
+      
+      author_name, permlink = parse_slug slug
+      discord_id = event.author.id
+      cb_account = Cosgrove::Account.find_by_discord_id(discord_id)
+      registered = !!cb_account
+      muted = muted by: steem_account, chain: :steem
+      
+      posts = SteemData::Post.root_posts.where(author: author_name, permlink: permlink)
+      votes_today = SteemData::AccountOperation.type('vote').where(voter: steem_account).today
+      today_count = votes_today.count
+      author_count = votes_today.where(author: author_name).count
+      vote_ratio = if today_count == 0
+        0.0
+      else
+        author_count.to_f / today_count
+      end
+      
+      post = posts.first
+      
+      if post.nil?
+        # Fall back to RPC
+        response = api(:steem).get_content(author_name, permlink)
+        unless response.result.author.empty?
+          post = response.result
+          created = Time.parse(post.created + 'Z')
+          cashout_time = Time.parse(post.cashout_time + 'Z')
+        end
+      end
+      
+      if post.nil?
+        cannot_find_input(event)
+        return
+      end
+      
+      created ||= post.created
+      cashout_time ||= post.cashout_time
+      
+      nope = if created > 5.minutes.ago
+        "Give it a second!  It's going to SPACE!  Can you give it a second to come back from space?"
+      elsif cashout_time < Time.now.utc
+        'Unable to vote on that.  Too old.'
+      elsif post.parent_permlink == 'nsfw'
+        puts "Won't vote because parent_permlink: nsfw"
+        'Unable to vote on that.'
+      elsif post.json_metadata.include?('nsfw')
+        puts "Won't vote because json_metadata includes: nsfw"
+        'Unable to vote on that.'
+      elsif post.active_votes.map{ |v| v['voter'] }.include?('blacklist-a')
+        puts "Won't vote blacklist-a voted."
+        'Unable to vote on that.'
+      elsif (rep = to_rep(post.author_reputation).to_f) < 25.0
+        puts "Won't vote because rep too low: #{rep}"
+        'Unable to vote on that.'
+      elsif muted.include? author_name
+        puts "Won't vote because author muted."
+        'Unable to vote.'
+      elsif !registered
+        'Unable to vote.  Feature resticted to registered users.'
+      elsif cb_account.novote?
+        'Unable to vote.  Your account has been resticted.'
+      elsif today_count > 10 && vote_ratio > 0.1
+        "Maybe later.  It seems like I've been voting for #{author_name} quite a bit lately."
+      elsif post.active_votes.map{ |v| v['voter'] }.include?(steem_account)
+        title = post.title
+        title = post.permlink if title.empty?
+        "I already voted on #{title} by #{post.author}."
+      end
+
+      if !!nope
+        event.respond nope
+        return
+      end
+      
+      vote = {
+        type: :vote,
+        voter: steem_account,
+        author: post.author,
+        permlink: post.permlink,
+        weight: upvote_weight(event.channel.id)
+      }
+
+      tx = new_tx :steem
+      op = Radiator::Operation.new(vote)
+      tx.operations << op
+      response = tx.process(true)
+
+      ap response.to_json
+
+      if !!response.error
+        'Unable to vote right now.  Maybe I already voted on that.  Try again later.'
+      elsif !!response.result.id
+        if created > 30.minutes.ago
+          event.respond "*#{SteemSlap.slap(event.author.display_name)}*"
+        end
+        
+        if !!@on_success
+          begin
+            @on_success.call(event, "@#{post.author}/#{post.permlink}")
+          rescue => e
+            ap e
+            ap e.backtrace
+          end
+        end
+        
+        "Upvoted: #{post.title} by #{author_name}"
+      else
+        ':question:'
+      end
+    end
+  private
+    def upvote_weight(channel_id = nil)
+      upvote_weight = cosgrove_upvote_weight
+      
+      case upvote_weight
+      when 'dynamic'
+        bot_account = find_account(steem_account)
+        upvote_weight = bot_account.voting_power.to_i
+      when 'upvote_rules'
+        upvote_weight = channel_upvote_weight(channel_id)
+        
+        if upvote_weight == 'dynamic'
+          bot_account = find_account(steem_account)
+          upvote_weight = bot_account.voting_power.to_i
+        else
+          upvote_weight = (((upvote_weight || '100.0 %').to_f) * 100).to_i
+        end
+      else
+        upvote_weight = (((upvote_weight || '100.0 %').to_f) * 100).to_i
+      end
+    end
+  end
+end

data/lib/cosgrove/utils.rb

@@ -0,0 +1,116 @@
+module Cosgrove
+  module Utils
+    include Cosgrove::Config
+    
+    def reset_api
+      @steem_api = @golos_api = @test_api = nil
+      @steem_folow_api = @golos_follow_api = @test_folow_api = nil
+      @cycle_api_at = nil
+    end
+    
+    def ping_api(chain)
+      response = api(chain).get_config
+      
+      reset_api if !!response.error
+      
+      result = response.result
+      reset_api unless result.keys.any?
+      
+      true
+    end
+    
+    def api(chain)
+      reset_api if @cycle_api_at.nil? || @cycle_api_at < 15.minutes.ago
+      
+      @cycle_api_at ||= Time.now
+      
+      case chain
+      when :steem then @steem_api ||= Radiator::Api.new(chain: :steem, url: steem_api_url)
+      when :golos then @golos_api ||= Radiator::Api.new(chain: :golos, url: golos_api_url)
+      when :test then @test_api ||= Radiator::Api.new(chain: :test, url: test_api_url)
+      end
+    end
+    
+    def follow_api(chain)
+      reset_api if @cycle_api_at.nil? || @cycle_api_at < 15.minutes.ago
+      
+      @cycle_api_at ||= Time.now
+      
+      case chain
+      when :steem then @steem_follow_api ||= Radiator::FollowApi.new(chain: :steem, url: steem_api_url)
+      when :golos then @golos_follow_api ||= Radiator::FollowApi.new(chain: :golos, url: golos_api_url)
+      when :test then @test_follow_api ||= Radiator::FollowApi.new(chain: :test, url: test_api_url)
+      end
+    end
+    
+    def steem_data_head_block_number
+      SteemData::Setting.last.last_block
+    end
+    
+    def properties(chain)
+      api(chain).get_dynamic_global_properties.result
+    end
+    
+    def head_block_number(chain)
+      properties(chain)['head_block_number']
+    end
+    
+    def last_irreversible_block_num(chain)
+      properties(chain)['last_irreversible_block_num']
+    end
+    
+    def new_tx(chain)
+      case chain
+      when :steem then Radiator::Transaction.new(chain: :steem, wif: steem_posting_wif, url: steem_api_url)
+      when :golos then Radiator::Transaction.new(chain: :golos, wif: golos_posting_wif, url: golos_api_url)
+      when :test then Radiator::Transaction.new(chain: :test, wif: test_posting_wif, url: test_api_url)
+      end
+    end
+    
+    def to_rep(raw)
+      raw = raw.to_i
+      neg = raw < 0
+      level = Math.log10(raw.abs)
+      level = [level - 9, 0].max
+      level = (neg ? -1 : 1) * level
+      level = (level * 9) + 25
+
+      '%.2f' % level
+    end
+    
+    def parse_slug(slug)
+      case slug
+      when /^latest:/ then find_author_name_permlink(slug)
+      when /^first:/ then find_author_name_permlink(slug)
+      else
+        slug = slug.split('@').last
+        author_name = slug.split('/')[0]
+        permlink = slug.split('/')[1..-1].join('/')
+        
+        [author_name, permlink]
+      end
+    end
+    
+    def find_author_name_permlink(slug)
+      op, author_name = slug.split(':')
+      author_name, offset = author_name.split(/[\+-]/)
+      author = find_account(author_name)
+      
+      offset = offset.to_i
+      
+      posts = if op == 'latest'
+        SteemData::Post.root_posts.where(author: author.name).order(created: :desc)
+      elsif op == 'first'
+        SteemData::Post.root_posts.where(author: author.name).order(created: :asc)
+      else
+        []
+      end
+      
+      if posts.any? && !!(post = posts[offset.to_i.abs])
+        return [author_name, post.permlink]
+      end
+      
+      []
+    end
+  end
+end