class Ruboty::Handlers::Redmine

Constants

NAMESPACE

Public Class Methods

new(*args) click to toggle source
Calls superclass method
# File lib/ruboty/handlers/redmine.rb, line 58
def initialize(*args)
  super
end

Public Instance Methods

active_paused_assignees() click to toggle source
# File lib/ruboty/handlers/redmine.rb, line 114
def active_paused_assignees
  paused_assignees.select do |a|
    Time.now < Time.at(a[:expire_at])
  end
end
assign_issues(message) click to toggle source
# File lib/ruboty/handlers/redmine.rb, line 120
def assign_issues(message)
  rule = {
    tracker: message[:tracker],
    project: message[:project],
    mention_name: message[:mention_name].gsub(/\A@/, ''),
    redmine_user_id: message[:redmine_user_id].gsub(/\A#/, '').to_i,
    notify_to: message[:channel].gsub(/\A#/, ''),
  }

  assignees << rule

  message.reply("Registered: #{rule}")
end
assignees() click to toggle source
# File lib/ruboty/handlers/redmine.rb, line 106
def assignees
  robot.brain.data["#{NAMESPACE}_assigns"] ||= []
end
create_issue(message) click to toggle source
# File lib/ruboty/handlers/redmine.rb, line 62
      def create_issue(message)
        from_name = message.original[:from_name]

        req = {}
        req[:subject] = "#{message[:subject]} (from #{from_name})"

        project = redmine.find_project(message[:project])
        unless project
          message.reply("Project '#{message[:project]}' is not found.")
          return
        end
        req[:project] = project

        tracker = redmine.find_tracker(message[:tracker])
        unless tracker
          message.reply("Tracker '#{message[:tracker]}' is not found.")
          return
        end
        req[:tracker] = tracker

        issue = redmine.create_issue(req)
        Ruboty.logger.debug("Created new issue: #{issue.inspect}")
        message.reply("Issue created: #{redmine.url_for_issue(issue)}")

        rules = assignees.select do |r|
          paused = active_paused_assignees.find do |a|
            a[:mention_name] == r[:mention_name]
          end
          next false if paused

          r[:project] == issue.project['name'] &&
            r[:tracker] == issue.tracker['name']
        end
        rule = rules[issue.id % rules.size]
        redmine.update_issue(issue, assigned_to_id: rule[:redmine_user_id])

        notify_slack(rule[:notify_to], <<-EOTEXT)
New Issue of #{issue.tracker['name']} in #{issue.project['name']} project
-> #{issue.subject}
-> Assigned to @#{rule[:mention_name]}
-> #{redmine.url_for_issue(issue)}
        EOTEXT
      end
list_assignees(message) click to toggle source
# File lib/ruboty/handlers/redmine.rb, line 134
def list_assignees(message)
  if assignees.empty?
    message.reply("No rule is found")
  end

  reply = assignees.map do |rule|
    "#{rule.object_id} #{rule}"
  end.join("\n")

  message.reply(reply)
end
list_paused_assignees(message) click to toggle source
# File lib/ruboty/handlers/redmine.rb, line 187
def list_paused_assignees(message)
  if paused_assignees.empty?
    message.reply("No paused assingee is found.")
    return
  end

  reply = active_paused_assignees.map do |a|
    "#{a[:mention_name]} (until #{Time.at(a[:expire_at])})"
  end.join("\n")

  message.reply(reply)
end
notify_slack(channel, message) click to toggle source
# File lib/ruboty/handlers/redmine.rb, line 220
def notify_slack(channel, message)
  slack_notifier.ping(
    text: message,
    channel: channel,
    username: 'ruboty',
    link_names: '1',
  )
end
parse_duration_to_sec(d) click to toggle source
# File lib/ruboty/handlers/redmine.rb, line 200
def parse_duration_to_sec(d)
  sum = 0
  d.scan(/(\d+)([smhdw])/) do |n, u|
    scale = case u
            when 's'
              1
            when 'm'
              60
            when 'h'
              60*60
            when 'd'
              24*60*60
            when 'w'
              7*24*60*60
            end
    sum += n.to_i + scale
  end
  sum
end
pause_assigning(message) click to toggle source
# File lib/ruboty/handlers/redmine.rb, line 157
def pause_assigning(message)
  mention_name = message[:mention_name]
  duration = message[:duration]

  expire_at = Time.now + parse_duration_to_sec(duration)

  pause = {
    mention_name: mention_name.gsub(/\A@/, ''),
    expire_at: expire_at.to_i
  }
  paused_assignees << pause

  message.reply("Paused: #{pause}")
end
paused_assignees() click to toggle source
# File lib/ruboty/handlers/redmine.rb, line 110
def paused_assignees
  robot.brain.data["#{NAMESPACE}_paused_assignees"] ||= []
end
redmine() click to toggle source
# File lib/ruboty/handlers/redmine.rb, line 233
def redmine
  @redmine ||= Ruboty::Redmine::Client.new(
    ENV['REDMINE_URL'],
    ENV['REDMINE_API_KEY'],
    basic_auth_user: ENV['REDMINE_BASIC_AUTH_USER'],
    basic_auth_password: ENV['REDMINE_BASIC_AUTH_PASSWORD'],
    http_proxy: ENV['REDMINE_HTTP_PROXY'],
  )
end
remove_redmine_assignee(message) click to toggle source
# File lib/ruboty/handlers/redmine.rb, line 146
def remove_redmine_assignee(message)
  id = message[:id].to_i
  rule = assignees.find {|r| r.object_id == id }
  if rule
    assignees.delete(rule)
    message.reply("Rule #{id} is removed")
  else
    message.reply("The rule is not found")
  end
end
slack_notifier() click to toggle source
# File lib/ruboty/handlers/redmine.rb, line 229
def slack_notifier
  @slack_notifier ||= Slack::Notifier.new(ENV['SLACK_WEBHOOK_URL'])
end
unpause_assigning(message) click to toggle source
# File lib/ruboty/handlers/redmine.rb, line 172
def unpause_assigning(message)
  mention_name = message[:mention_name].gsub(/\A@/, '')

  prev_size = paused_assignees.size
  paused_assignees.reject! do |a|
    a[:mention_name] == mention_name
  end

  if parsed_assignees.size == prev_size
    message.reply("No paused assignee is found")
  else
    message.reply("Unpaused")
  end
end