sd-ruby-libs 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5585ce25566d5dfdf7447411490f187c5e1292e0
+  data.tar.gz: 499df0a567a0afc06d66c40bfac727acc584a41a
+SHA512:
+  metadata.gz: a73fce6fbdc1496e6752b1cd312eff00056e5b323476897ba79c004e0bf4032acb430b092a981f2c7987f2792a3ba05df45b7a1fd77ab69389e0205048e8fa41
+  data.tar.gz: d55c92da3739ffa84900a4b80846fd94329bd495b461bc27b742e2dd97d791ded9e7ac96a0bdf3a17502de3c53f51c8256ef2c89693a4bf045d1ea07c870d41b

data/.rubocop.yml

@@ -0,0 +1,3 @@
+---
+Metrics/LineLength:
+  Enabled: false

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/excel_reports.rb

@@ -0,0 +1,57 @@
+require 'writeexcel'
+require 'write_xlsx'
+
+# `Generic` 2d Data set to excel file generator
+module ExcelReports
+  Youtube_time_link = Struct.new(:video, :time) do
+    def time_in_seconds
+      return 0 unless time
+      segments = time.split(':')
+      (segments[0].to_i * 3600) + (segments[1].to_i * 60) + segments[2].to_i
+    rescue
+      return 0
+    end
+
+    def excel_hyperlink
+      return '' unless time
+      "=hyperlink(\"https://youtu.be/#{video}?t=#{time_in_seconds}\", \"#{time}\")"
+    end
+
+    def to_s
+      time
+    end
+  end
+
+  def multi_array_to_xlsx(column_info, data, filename, freeze_panes: nil)
+    workbook ||= WriteXLSX.new("#{filename}.xlsx")
+
+    format_heading = workbook.add_format # Add a format
+    format_heading.set_bold
+    format_heading.set_align('center')
+
+    data.each do |sheet|
+      worksheet = workbook.add_worksheet sheet.first
+
+      worksheet.freeze_panes(freeze_panes[:y], freeze_panes[:x]) if freeze_panes
+
+      row = 0
+
+      column_info.each_with_index do |column, index|
+        worksheet.set_column(index, index, column[1])
+        worksheet.write(row, index, column.first, format_heading)
+      end
+      row = row.next
+
+      next unless sheet.last
+      sheet.last.each do |record|
+        record.each_with_index do |cell, index|
+          worksheet.write(row, index, cell) unless cell.last
+          worksheet.write(row, index, cell.last) if cell.last
+        end
+        row = row.next
+      end
+    end
+
+    workbook.close
+  end
+end

data/google_drive.rb

@@ -0,0 +1,73 @@
+require 'google/apis/drive_v3'
+require 'googleauth'
+require 'googleauth/stores/file_token_store'
+require 'pry'
+require 'fileutils'
+
+class GoogleDriveHelper
+  def initialize
+    @GDRIVE_OOB_URI = 'urn:ietf:wg:oauth:2.0:oob'
+    @GDRIVE_APPLICATION_NAME = 'Drive API Ruby Quickstart'
+    @GDRIVE_CLIENT_SECRETS_PATH = 'drive_client_secret.json'
+    @GDRIVE_CREDENTIALS_PATH = File.join(Dir.home, '.credentials',
+                                  "drive-ruby-permissions.yaml")
+    @GDRIVE_SCOPE = Google::Apis::DriveV3::AUTH_DRIVE
+  end
+
+  ##
+  # Ensure valid credentials, either by restoring from the saved credentials
+  # files or intitiating an OAuth2 authorization. If authorization is required,
+  # the user's default browser will be launched to approve the request.
+  #
+  # @return [Google::Auth::UserRefreshCredentials] OAuth2 credentials
+  def authorize
+    FileUtils.mkdir_p(File.dirname(@GDRIVE_CREDENTIALS_PATH))
+
+    client_id = Google::Auth::ClientId.from_file(@GDRIVE_CLIENT_SECRETS_PATH)
+    token_store = Google::Auth::Stores::FileTokenStore.new(file: @GDRIVE_CREDENTIALS_PATH)
+    authorizer = Google::Auth::UserAuthorizer.new(
+      client_id, @GDRIVE_SCOPE, token_store)
+    user_id = 'default'
+    credentials = authorizer.get_credentials(user_id)
+    if credentials.nil?
+      url = authorizer.get_authorization_url(
+        base_url: @GDRIVE_OOB_URI)
+      puts "Open the following URL in the browser and enter the " +
+           "resulting code after authorization"
+      puts url
+      code = gets
+      credentials = authorizer.get_and_store_credentials_from_code(
+        user_id: user_id, code: code, base_url: @GDRIVE_OOB_URI)
+    end
+    credentials
+  end
+
+  def share_document(document, email_address)
+    # Initialize the API
+    service = Google::Apis::DriveV3::DriveService.new
+    service.client_options.application_name = @GDRIVE_APPLICATION_NAME
+    service.authorization = authorize
+
+    file_id = document
+    callback = lambda do |res, err|
+      if err
+        # Handle error...
+        puts errb.psqlody
+      else
+#        puts "Permission ID: #{res.id}"
+      end
+    end
+
+    service.batch do |drive|
+      user_permission = {
+        type: 'user',
+        role: 'writer',
+        email_address: email_address
+      }
+      drive.create_permission(file_id,
+                              user_permission,
+                              fields: 'id',
+                              &callback)
+    end
+  end
+end

data/google_sheets.rb

@@ -0,0 +1,398 @@
+require 'google/apis/sheets_v4'
+require 'googleauth'
+require 'googleauth/stores/file_token_store'
+require '../rubyLibs/google_drive.rb'
+require 'pry'
+require 'fileutils'
+
+OOB_URI = 'urn:ietf:wg:oauth:2.0:oob'.freeze
+APPLICATION_NAME = 'Google Sheets API Export Tool'.freeze
+CLIENT_SECRETS_PATH = 'client_secret.json'.freeze
+
+begin
+  CREDENTIALS_PATH = File.join(Dir.home, '.credentials',
+                             'sheets.googleapis.com-ruby-quickstart.yaml')
+rescue StandardError
+  # @todo had to catch for error when home isn't 'set'. need to find better place for creds to go
+  CREDENTIALS_PATH = File.join('/root/.credentials',
+                               'sheets.googleapis.com-ruby-quickstart.yaml')
+end
+# SCOPE = Google::Apis::SheetsV4::AUTH_SPREADSHEETS_READONLY
+SCOPE = Google::Apis::SheetsV4::AUTH_SPREADSHEETS
+
+##
+# Ensure valid credentials, either by restoring from the saved credentials
+# files or intitiating an OAuth2 authorization. If authorization is required,
+# the user's default browser will be launched to approve the request.
+#
+# @return [Google::Auth::UserRefreshCredentials] OAuth2 credentials
+def authorize
+  FileUtils.mkdir_p(File.dirname(CREDENTIALS_PATH))
+
+  client_id = Google::Auth::ClientId.from_file(CLIENT_SECRETS_PATH)
+  token_store = Google::Auth::Stores::FileTokenStore.new(file: CREDENTIALS_PATH)
+  authorizer = Google::Auth::UserAuthorizer.new(
+    client_id, SCOPE, token_store
+  )
+  user_id = 'default'
+  credentials = authorizer.get_credentials(user_id)
+  if credentials.nil?
+    url = authorizer.get_authorization_url(
+      base_url: OOB_URI
+    )
+    puts 'Open the following URL in the browser and enter the ' \
+         'resulting code after authorization'
+    puts url
+    code = gets
+    credentials = authorizer.get_and_store_credentials_from_code(
+      user_id: user_id, code: code, base_url: OOB_URI
+    )
+  end
+  credentials
+end
+
+# Utility class to export data into specified sheet id, overwrites existing sheets completely
+class GoogleSheetsExporter
+  attr_accessor :headers, :spreadsheet_id, :data, :sheets, :service, :email_address, :document_name
+
+  def initialize(headers, spreadsheet_id, data, email_address = nil, document_name = nil)
+    @headers = headers
+
+    @email_address = email_address
+    @document_name = document_name
+
+    @data = data
+
+    # initialize api
+    @sheets = Google::Apis::SheetsV4
+    @service = Google::Apis::SheetsV4::SheetsService.new
+    @service.client_options.application_name = APPLICATION_NAME
+    @service.authorization = authorize
+
+    return unless spreadsheet_id
+    @spreadsheet_id = spreadsheet_id unless spreadsheet_id && spreadsheet_id['https://']
+    begin
+      @spreadsheet_id = spreadsheet_id.match(%r{/([^/]{44})[/]?})[1] if spreadsheet_id['https://']
+    rescue
+      puts "Provided spreadsheet address does not work."
+    end
+  end
+
+  def spreadsheet_url
+    "https://docs.google.com/spreadsheets/d/#{spreadsheet_id}/"
+  end
+
+  def sheet_id_from_name(sheet_name)
+    retries ||= 0
+    service
+      .get_spreadsheet(spreadsheet_id)
+      .to_h[:sheets]
+      .select { |sheet| sheet[:properties][:title] == sheet_name }
+      .first[:properties][:sheet_id]
+  rescue StandardError => e
+    puts "Sheet name #{sheet_name} not found. Retry #{retries}"
+    sleep 5 ** (retries + 1) / 10.to_f
+    retry if (retries += 1) < 6
+    return 0
+  end
+
+  def batch_update(request)
+    batch = sheets::BatchUpdateSpreadsheetRequest.new(request)
+
+    begin
+      retries ||= 0
+      service.batch_update_spreadsheet spreadsheet_id, batch, {}
+    rescue StandardError => e
+      binding.pry if ENV['HACKING']
+      return true if e.to_s['already exists']
+      return false if e.to_s['Requested entity was not found.']
+      puts "Error with google API calling #{request} on retry #{retries}"
+      puts e
+      sleep 5 ** (retries + 1) / 10.to_f
+      retry if (retries += 1) < 6 and not e.to_s['Invalid request']
+    end
+  end
+
+  def auto_resize_sheet(sheet)
+    batch_update(requests: [
+                   {
+                     auto_resize_dimensions: {
+                       dimensions: {
+                         sheet_id: sheet_id_from_name(sheet.first),
+                         dimension: 'COLUMNS'
+                       }
+                     }
+                   }
+                 ])
+  end
+
+  def sheet_default_font(sheet)
+    batch_update(requests: [
+                   {
+                     repeat_cell: {
+                       range: {
+                         sheet_id: sheet_id_from_name(sheet.first)
+                       },
+                       cell: {
+                         user_entered_format: {
+                           text_format: {
+                             font_size: 11,
+                             font_family: 'Arial'
+                           }
+                         }
+                       },
+                       fields: 'user_entered_format(text_format, horizontal_alignment)'
+                     }
+                   }
+                 ])
+  end
+
+  def bold_row(sheet, start_row_index, end_row_index)
+    batch_update(requests: [
+                   {
+                     repeat_cell: {
+                       range: {
+                         sheet_id: sheet_id_from_name(sheet.first),
+                         start_row_index: start_row_index,
+                         end_row_index: end_row_index + 1
+                       },
+                       cell: {
+                         user_entered_format: {
+                           horizontal_alignment: 'CENTER',
+                           text_format: {
+                             foreground_color: {
+                               red: 20.0 / 255,
+                               green: 108.0 / 255,
+                               blue: 124.0 / 255
+                             },
+                             font_size: 11,
+                             bold: true
+                           }
+                         }
+                       },
+                       fields: 'user_entered_format(text_format, horizontal_alignment)'
+                     }
+                   },
+                   {
+                     update_sheet_properties: {
+                       properties: {
+                         sheet_id: sheet_id_from_name(sheet.first),
+                         grid_properties: {
+                           frozen_row_count: 1
+                         }
+                       },
+                       fields: 'grid_properties.frozen_row_count'
+                     }
+                   }
+                 ])
+  end
+
+  def format_column(sheet, start_column_index, end_column_index, horizontal_alignment = 'left', bold = false, font_size = 11)
+    horizontal_alignment = 'left' unless horizontal_alignment
+    batch_update(requests: [
+                   {
+                     repeat_cell: {
+                       range: {
+                         sheet_id: sheet_id_from_name(sheet.first),
+                         start_column_index: start_column_index,
+                         end_column_index: end_column_index + 1
+                       },
+                       cell: {
+                         user_entered_format: {
+                           horizontal_alignment: horizontal_alignment.upcase,
+                           text_format: {
+                             font_size: font_size,
+                             bold: bold
+                           }
+                         }
+                       },
+                       fields: 'user_entered_format(text_format, horizontal_alignment)'
+                     }
+                   }
+                 ])
+  end
+
+  def number_format_column(sheet, start_column_index, end_column_index, pattern = '#,##0.00')
+    batch_update(requests: [
+                   {
+                     repeat_cell: {
+                       range: {
+                         sheet_id: sheet_id_from_name(sheet.first),
+                         start_column_index: start_column_index,
+                         end_column_index: end_column_index + 1
+                       },
+                       cell: {
+                         user_entered_format: {
+                           number_format: {
+                             type: 'NUMBER',
+                             pattern: pattern
+                           }
+                         }
+                       },
+                       fields: 'user_entered_format(number_format)'
+                     }
+                   }
+                 ])
+  end
+
+  def create_temp_sheet
+    batch_update(requests: [{
+                   add_sheet: {
+                     properties: {
+                       title: 'temp-sheet',
+                       grid_properties: {
+                         column_count: 1
+                       }
+                     }
+                   }
+                 }])
+  end
+
+  def delete_all_sheets
+    service
+      .get_spreadsheet(spreadsheet_id)
+      .to_h[:sheets]
+      .select { |sheet| sheet[:properties][:title] != 'temp-sheet' }
+      .each do |sheet|
+      batch_update(requests: [{
+                     delete_sheet: {
+                       sheet_id: sheet[:properties][:sheet_id]
+                     }
+                   }])
+    end
+  end
+
+  def column_from_index(index)
+    %w(A B C D E F G H I J K L M N O P Q R S T U V W X Y Z)[index - 1]
+  end
+
+  def populate_new_sheets
+    threads = []
+    data.each do |sheet|
+      # threads.push Thread.new {
+
+      begin
+      batch_update(requests: [{
+                     add_sheet: {
+                       properties: {
+                         title: sheet.first,
+                         grid_properties: {
+                           column_count: sheet.last.first.count
+                         }
+                       }
+                     }
+                   }])
+
+      rescue
+        binding.pry if ENV['HACKING']
+        puts sheet
+        puts "invalid or no data, skipping"
+        next
+      end
+      sheet_default_font(sheet)
+
+      headers.each_with_index do |header, index|
+        format_column sheet, index, index, header[1]
+        number_format_column sheet, index, index, header[2] if header[2]
+      end
+
+      value_range_object = {
+        major_dimension: 'ROWS',
+        values: [headers.map(&:first)]
+      }
+
+      range = sheet.first
+
+      begin
+        retries ||= 0
+        service.update_spreadsheet_value(spreadsheet_id, range, value_range_object, value_input_option: 'USER_ENTERED')
+      rescue StandardError => e
+        puts "Failed to save data, retry #{retries}"
+        puts e
+        sleep 5 ** (retries + 1) / 10.to_f
+        retry if (retries += 1) < 6
+      end
+
+      bold_row(sheet, 0, 0)
+
+      if sheet.last.first.respond_to?('values')
+        value_range_object = {
+          major_dimension: 'ROWS',
+          values: sheet.last.map(&:values)
+        }
+      else
+        value_range_object = {
+          major_dimension: 'ROWS',
+          values: sheet.last.map(&:itself)
+        }
+      end
+
+      range = "#{sheet.first}!A2:#{column_from_index headers.count}#{sheet.last.count + 1}"
+
+      begin
+        retries ||= 0
+
+        service.update_spreadsheet_value(spreadsheet_id, range, value_range_object, value_input_option: 'USER_ENTERED')
+      rescue StandardError => e
+        puts "Failed to save data, retry #{retries}"
+        puts e
+        sleep 5 ** (retries + 1) / 10.to_f
+        retry if (retries += 1) < 6
+      end
+
+      auto_resize_sheet(sheet)
+      # }
+    end
+
+    threads.each(&:join)
+  end
+
+  def delete_temp_sheet
+    service
+      .get_spreadsheet(spreadsheet_id)
+      .to_h[:sheets]
+      .select { |sheet| sheet[:properties][:title] == 'temp-sheet' }
+      .each do |sheet|
+      batch_update(requests: [{
+                     delete_sheet: {
+                       sheet_id: sheet[:properties][:sheet_id]
+                     }
+                   }])
+    end
+  end
+
+  def update_google_sheet
+    return puts "Invalid Google Sheet. Please make sure it is shared with sdegabriele@bbtv.com" unless create_temp_sheet
+    delete_all_sheets
+    populate_new_sheets
+    delete_temp_sheet
+  end
+
+  def create_sheet
+    request_body = Google::Apis::SheetsV4::Spreadsheet.new
+    response = service.create_spreadsheet(request_body)
+    @spreadsheet_id = response.spreadsheet_id
+
+    requests = []
+    requests.push(
+      update_spreadsheet_properties: {
+        properties: { title: document_name },
+        fields: 'title'
+      }
+    )
+    batch_update(requests: requests)
+  end
+
+  def share_sheet
+    GoogleDriveHelper.new.share_document(spreadsheet_id, email_address)
+  end
+
+  def create_google_sheet
+    create_sheet
+    share_sheet
+    create_temp_sheet
+    delete_all_sheets
+    populate_new_sheets
+    delete_temp_sheet
+  end
+end

data/number_format.rb

@@ -0,0 +1,3 @@
+def number_format(number)
+  number.to_s.gsub(/(\d)(?=(\d\d\d)+(?!\d))/, '\\1,')
+end

data/sd-ruby-libs.gemspec

@@ -0,0 +1,20 @@
+Gem::Specification.new do |gem|
+  gem.name        = 'sd-ruby-libs'
+  gem.version     = `git describe --tags --abbrev=0`.chomp
+  gem.summary     = "various tools"
+  gem.description = "basic slack and google sheets functionality"
+  gem.authors     = ["Stephen DeGabriele"]
+  gem.email       = 'someguy@degabriele.com'
+
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f)  }
+  gem.require_paths = ['lib']
+
+  gem.add_runtime_dependency 'google-api-client', '~> 0.13.4', '>= 0.13.4'
+  gem.add_runtime_dependency 'googleauth', '~> 0.5.3', '>= 0.5.3'
+  gem.add_runtime_dependency 'slack-api', '~> 1.6.0', '>= 1.6.0'
+  gem.add_runtime_dependency 'write_xlsx', '~> 0.85.1', '>= 0.85.1'
+  gem.add_runtime_dependency 'writeexcel', '~> 1.0.5', '>= 1.0.5'
+  gem.add_runtime_dependency 'pry'
+end

data/slack-bot.rb

@@ -0,0 +1,181 @@
+#!/usr/bin/env ruby
+require 'slack'
+require 'kanban'
+require 'yaml'
+require 'redis'
+require 'json'
+require 'pry'
+
+# Simple wrapper for the slack ruby interface
+module SlackNotification
+  def initialize
+    @restarts = 0
+    @config = YAML.load_file(ENV['SLACKCONFIG'] || 'slackConfig.yaml')
+
+    Slack.configure do |config|
+      config.token = @config['slack_token']
+    end
+  end
+
+  def redis
+    @redis ||= Redis.new
+  end
+
+  def worker_backlog
+    @worker_backlog ||= Kanban::Backlog.new backend: Redis.new(db: 3), namespace: "#{name}-worker"
+  end
+
+  def dispatch_backlog
+    @dispatch_backlog ||= Kanban::Backlog.new backend: Redis.new(db: 3), namespace: "#{name}-dispatch"
+  end
+
+  def client
+    @client ||= Slack::Client.new
+  end
+
+  def create_channel
+    @config['slack_channels'].each do |channel|
+      client.groups_create(name: channel)
+    end
+  end
+
+  def invite(who)
+    @config['slack_channels'].each do |channel|
+      client.groups_invite(channel: channel, user: who)
+    end
+  end
+
+  def create_interface(*message)
+    create_channel
+    invite message.first['user']
+    help
+  end
+
+  def name
+    @config['slack_name']
+  end
+
+  def help(message)
+    send_notification(known_commands.to_s, message['channel'])
+  end
+
+  def parse_command(message)
+    unsure = [
+      "I heard my name.... instructions unclear. `#{name} help` might be what you need. :dog:",
+      ":dog: Sometimes when you say my name I think you are going to give me a treat. `#{name} help` :dog:",
+      ":dog: wag :dog: `#{name} help` might be what you want.",
+      "woof.  Not sure what you mean.  Please try \"#{name} help\"",
+      ":dog: feeling confused? Me too.  Might be a good time for a sandwich! then try \"#{name} help\"",
+      "http://puppyloveblog.com/scaled/600x450/taro-the-black-labrador-puppy-and-his-sad-puppy-dog-eyes-451.jpg Try `#{name} help` for assistance.",
+      "http://puppyloveblog.com/scaled/600x450/taro-the-black-labrador-puppy-being-cute-519.jpg  `#{name} help` to see what i can do.",
+      "http://puppyloveblog.com/scaled/600x337/kratos-and-his-rope-what-a-handsome-black-labrador-retriever-puppy-471.jpg  `#{name} help` will pull up the list of commands i know"
+    ]
+    send_notification(unsure.sample, message['channel'])
+  end
+
+  def bot_message?(m)
+    m['subtype'] && m['subtype'] == 'bot_message'
+  end
+
+  def magic_phrase?(m)
+    return unless m['text'] && m['text'].start_with?("#{name} juice #{name} juice #{name} juice")
+    send_notification "It's showtime #{m}", m['channel']
+    # need to have auth users before using this
+    # create_interface m
+    true
+  end
+
+  def configured_channel?(m)
+    return false if @config['slack_blacklist_channels'] && @config['slack_blacklist_channels'].include?(m['channel'])
+    @config['slack_channels'].include? m['channel'] or @config['any_channel']
+  end
+
+  def message_for_bot?(m)
+    m['text'] && m['text'].start_with?(name)
+  end
+
+  def valid_command(command_matrix, m)
+    commands = command_matrix.select do |keyword|
+      m['text'].start_with? "#{name} #{keyword.first}"
+    end
+
+    [commands.sort_by { |command| command.first.length }.reverse.first]
+  end
+
+  def skip_message?(m)
+    return true if bot_message? m
+    return true if magic_phrase? m
+    return true unless configured_channel? m
+    return true unless message_for_bot? m
+  end
+
+  def queue_command(command, message)
+    message['command'] = command
+    job = { 'task' => JSON.dump(message) }
+    worker_backlog.add job
+  end
+
+  def perform_command(matrix, m)
+    action = valid_command(matrix, m) - [nil]
+    return send_notification("Command not known.  Please try help.", m['channel']) unless action
+    return send('parse_command', m) if action.count.zero?
+    return send_notification("It is not clear what you want.  Valid matching actions are: #{action}", m['channel']) if action.count > 1
+    queue_command(action.first.last, m)
+  end
+
+  def worker
+    loop do
+      task_id = worker_backlog.claim(duration: 999999)
+      message = JSON.parse(worker_backlog.get(task_id)['task'])
+      command = message['command']
+      puts "Debug info: command = #{command} message = #{message}"
+      send(command, message)
+      worker_backlog.complete task_id
+    end
+  end
+
+  def real_time(matrix, restarted = false)
+    rtm = client.realtime
+    message_count = 0
+    rtm.on :message do |m|
+      puts m if ENV['DEBUGGING']
+      message_count += 1
+      next if restarted && message_count == 1
+      next if skip_message? m
+      perform_command matrix, m
+    end
+    rtm.start
+  end
+
+  def send_binary_file(file, override_filename = nil)
+    puts "Sending binary file: #{file}"
+    override_filename = file.split('/').last unless override_filename
+    `curl -F file=@#{file} -F channels=#{@config['slack_channels'].first} -F token=#{@config['slack_token']} -F filename=#{override_filename}  https://slack.com/api/files.upload 2>&1`
+  end
+
+  def queue_notification(message, channel = nil)
+    task = {
+      message: message,
+      channel: channel ? channel : @config['slack_channels'].first
+    }
+    job = { 'task' => JSON.dump(task) }
+    dispatch_backlog.add job
+  end
+
+  def transmission
+    loop do
+      task_id = dispatch_backlog.claim(duration: 999999)
+      job = JSON.parse(dispatch_backlog.get(task_id)['task'])
+      next unless job['message']
+      puts "Debug info: channel = #{job['channel']} message = #{job['message']}"
+      send_notification job['message'], job['channel']
+    end
+  end
+
+  def send_notification(message, channel = nil)
+    return queue_notification message, channel unless ENV['TRANSMISSION']
+    puts "Sending notification: #{message}"
+    channel ||= @config['slack_channels'].first
+    client.chat_postMessage(channel: channel, text: message, as_user: false, username: @config['slack_name'])
+  end
+end

metadata

@@ -0,0 +1,164 @@
+--- !ruby/object:Gem::Specification
+name: sd-ruby-libs
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Stephen DeGabriele
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-02-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: google-api-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.13.4
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.13.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.13.4
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.13.4
+- !ruby/object:Gem::Dependency
+  name: googleauth
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.3
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.5.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.3
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.5.3
+- !ruby/object:Gem::Dependency
+  name: slack-api
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+- !ruby/object:Gem::Dependency
+  name: write_xlsx
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.85.1
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.85.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.85.1
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.85.1
+- !ruby/object:Gem::Dependency
+  name: writeexcel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.5
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.5
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.5
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: basic slack and google sheets functionality
+email: someguy@degabriele.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rubocop.yml"
+- Gemfile
+- excel_reports.rb
+- google_drive.rb
+- google_sheets.rb
+- number_format.rb
+- sd-ruby-libs.gemspec
+- slack-bot.rb
+homepage: 
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2.1
+signing_key: 
+specification_version: 4
+summary: various tools
+test_files: []