confuddle 0.0.1

data/.gitignore

@@ -0,0 +1,18 @@
+.DS_Store
+log
+log/*.log
+tmp/*
+nbproject
+.tmp_*
+.project
+.idea/**/*
+.idea/*
+.idea
+.rakeTasks
+*.iml
+*.pid
+database.yml
+*.auth
+.generators
+.rakeTasks
+*.gem

data/.passwd_to_unfuddle.example.yml

@@ -0,0 +1,7 @@
+subdomain: kripton
+username: superman
+password: ihateluther
+default_project_id: 54321 # ticket number 1234 or #1234
+projects_aliases:
+  54321: a # number like a#1234
+  12345: b # number like b#1234

data/README.md

@@ -0,0 +1,40 @@
+Console Unfuddle
+================
+
+Utility for work with unfuddle.com account from console
+
+1. gem install confuddle
+2. un install
+3. Edit HOME_DIR/.passwd_to_unfuddle.yml and fill with your own values
+4. $ un projects
+and set for each project aliases "un alias"
+and set current project "un curr"
+
+Tasks:
+
+    un addcm NUMBER                       # add ticket comment
+    un addt NUMBER HOURS COMMENT [DATE]   # add time
+    un alias PROJECT_ID ALIAS             # set project alias
+    un all [REGEXP]                       # show all tickets for current project
+    un alla [REGEXP]                      # show all (in all projects) tickets
+    un assi TICKETS [NEW_ASSIGNEE]        # update tickets assingee
+    un at PERIOD                          # show all times report for account (PERIOD = [tm lm tw lw y [0-9]+])
+    un atm PERIOD                         # show my times report for account (PERIOD = [tm lm tw lw y [0-9]+])
+    un clear                              # clear caches
+    un curr ID_OR_ALIAS                   # set current project id
+    un help [TASK]                        # Describe available tasks or one specific task
+    un my                                 # show tickets assignee to me for current project
+    un mya                                # show tickets (in all projects) assignee to me
+    un new ALIAS TITLE [ASSIGNEE] [PRIO]  # create ticket
+    un notify PARAMS                      # Notify about changes with tickets by Gnome-Notify, PARAMS='status,comments'
+    un op TICKET_ID                       # Open selected ticked from current project in browser
+    un projects                           # show all projects for your account
+    un show NUMBER [t]                    # show ticket by number, [t] - show TimeEntries
+    un t PERIOD                           # show all times report (PERIOD = [tm lm tw lw y [0-9]+])
+    un tm PERIOD                          # show my times report (PERIOD = [tm lm tw lw y [0-9]+])
+    un upd TICKETS NEW_STATUS             # update tickets statuses
+
+Used gems:
+
+    unfuzzle by Patrick Reagan of Viget Labs
+    grapt by Patrick Reagan

data/bin/un

@@ -0,0 +1,833 @@
+#!/usr/bin/env ruby
+
+# Console Unfuddle
+# by Makarchev K. 2011
+# by Varamashvili M. 2011
+
+WIN = RUBY_PLATFORM['mingw'] || RUBY_PLATFORM['mswin']
+MAC = RUBY_PLATFORM['darwin']
+
+$KCODE='u' if RUBY_VERSION <= "1.8.7"
+
+require 'rubygems'
+require 'yaml'
+require 'active_support'
+require 'active_support/time'
+
+if(WIN)
+  require 'iconv'
+  require 'win32console'
+  require File.expand_path(File.join(File.dirname(__FILE__), %w(.. lib unfuzzle lib unfuzzle) ))
+else
+  dirname = File.symlink?(__FILE__) ? File.dirname(File.readlink(__FILE__)) : File.dirname(__FILE__)
+  require File.expand_path(File.join(dirname, %w(.. lib unfuzzle lib unfuzzle) ))
+end
+
+require 'thor'
+require 'readline'
+
+class Unfuddle < Thor
+
+  UNFUDDLE_ENC = "utf-8"
+  WIN_ENC = "cp866"
+  CMD_WIN_ENC = "windows-1251"
+  HOME_DIR = ENV['HOME']
+  PASS_FILE = File.expand_path("#{HOME_DIR}/.passwd_to_unfuddle.yml")
+  CACHED_PEOPLE = "#{HOME_DIR}/.cached_people.yml"
+  CACHED_PROJECTS = "#{HOME_DIR}/.cached_projects.yml"
+  CACHED_TICKETS = "#{HOME_DIR}/.cached_tickets.yml"
+  CACHED_PERIOD = 10.days
+  CACHED_PROJECTS_PERIOD = 10.days
+  CACHED_TICKETS_PERIOD = 60 * 60
+
+  attr_accessor :default_project_id, :projects_aliases
+
+  def initialize(*args)
+    task_name = args[2][:current_task].name rescue 'unknown'
+
+    unless task_name == 'install'
+
+      get_config
+
+      unless me_id
+        say "Error: no matches for me", :red, true
+        exit 1
+      end
+
+      @started_at = Time.now
+    end
+
+    super
+  end
+
+
+private
+  def get_config
+    unless File.exists?(PASS_FILE)
+      say "Error: not found #{PASS_FILE}, call `un install`", :red, true
+      exit 1
+    end
+
+    cfg = YAML.load_file(PASS_FILE)
+    Unfuzzle.subdomain = cfg['subdomain']
+    Unfuzzle.username  = cfg['username']
+    Unfuzzle.password  = cfg['password']
+    Unfuzzle.use_ssl   = true
+
+    self.default_project_id = cfg['default_project_id']
+    self.default_project_id = cached_projects.keys.first if default_project_id.blank? || ([self.default_project_id] & cached_projects.keys).empty?
+
+    self.projects_aliases = cfg['projects_aliases'] || {}
+  end
+
+  def set_config
+    h = {}
+    h['subdomain'] = Unfuzzle.subdomain
+    h['username'] = Unfuzzle.username
+    h['password'] = Unfuzzle.password
+
+    h['default_project_id'] = self.default_project_id
+    h['projects_aliases'] = self.projects_aliases
+
+    File.open(PASS_FILE, "w+"){ |file| file.puts(h.to_yaml) }
+  end
+
+  if WIN    
+    def say(*args)
+      args[0] = Iconv.new(WIN_ENC, UNFUDDLE_ENC).iconv(args.at(0).to_s) rescue args.at(0).to_s
+      super
+    end
+  end
+
+  def enc_input(text)
+    if WIN
+      Iconv.new(UNFUDDLE_ENC, WIN_ENC).iconv(text.to_s)
+    else
+      text
+    end    
+  end
+
+  def enc_cmd(text)
+    if WIN
+      Iconv.new(UNFUDDLE_ENC, CMD_WIN_ENC).iconv(text.to_s)
+    else
+      text
+    end    
+  end
+
+  def color(prio)
+    case prio
+      when 1; :blue
+      when 2; :cyan
+      when 3; nil
+      when 4; :red
+      when 5; :on_red
+    end
+  end
+
+  def read_text
+    lines = []
+    while line = Readline::readline("> ")
+      lines << line
+    end
+
+  rescue Interrupt => e
+  ensure
+    return enc_input(lines * "\n")
+  end
+
+  # people {id => name}
+  def people
+    @people ||= {}.tap do |h|
+      cached_people.each{|id, data| h[id] = data[:name] }
+    end
+  end
+
+  # cached people
+  def cached_people
+    return @cached_people if @cached_people
+
+    # cached peoples
+    if File.exists?(CACHED_PEOPLE) && File.ctime(CACHED_PEOPLE) > (Time.now - CACHED_PERIOD)
+      @cached_people = YAML.load_file(CACHED_PEOPLE)
+    else
+      people = Unfuzzle::Person.all
+      @cached_people = {}
+      people.each do |person|
+        name = if person.last_name.to_s.blank?
+          person.first_name.to_s.split(" ").reverse.join(" ")
+        else
+          person.last_name.to_s + " " + person.first_name.to_s
+        end
+        name = name.split(" ")
+        if name.size > 0
+          name[1] = name[1].to_s.mb_chars[0].to_s + "."
+        end
+        name = name.join(" ")
+        @cached_people[person.id] = {:name => name, :login => person.username}
+      end
+      File.open(CACHED_PEOPLE, 'w'){|f| f.write(YAML.dump(@cached_people))}
+    end
+
+    @cached_people
+  end
+  
+  # my id
+  def me_id
+    @me_id ||= cached_people.detect{|id, data| data[:login] == Unfuzzle.username}.at(0)
+  end
+
+  def me  
+    @me ||= people[me_id]
+  end
+
+
+  def cached_projects
+    return @cached_projects if @cached_projects
+
+    # cached peoples
+    if File.exists?(CACHED_PROJECTS) && File.ctime(CACHED_PROJECTS) > (Time.now - CACHED_PROJECTS_PERIOD)
+      @cached_projects = YAML.load_file(CACHED_PROJECTS)
+    else
+      projects = Unfuzzle.projects
+      @cached_projects = {}
+      projects.each do |project|
+        @cached_projects[project.id] = project.name
+      end
+      File.open(CACHED_PROJECTS, 'w'){|f| f.write(YAML.dump(@cached_projects))}
+    end
+
+    @cached_projects
+  end
+
+  def cached_tickets(params)
+    return @cached_tickets if @cached_tickets
+    if File.exists?(CACHED_TICKETS)
+      yaml = YAML.load_file(CACHED_TICKETS)
+      @cached_tickets = yaml[params.to_s] || []
+    else
+      @cached_tickets = []
+    end
+    @cached_tickets
+  end
+
+  def set_cached_tickets(t, params)
+    yaml = if File.exists?(CACHED_TICKETS)
+      YAML.load_file(CACHED_TICKETS)
+    else
+      {}
+    end
+
+    yaml[params.to_s] = t.map(&:to_hash)
+
+    File.open(CACHED_TICKETS, 'w'){|f| f.write(YAML.dump(yaml))}
+  end
+
+  # number with alias
+  def number_with_a(ticket)
+    number_with_a_by_params(ticket.project_id, ticket.number)
+  end
+
+  def number_with_a_by_params(project_id, number)
+    return number.to_s if project_id == self.default_project_id
+    self.projects_aliases[ project_id ].to_s + number.to_s
+  end
+
+  def find_project_id_by_alias(al)
+    return default_project_id if al.blank?
+
+    res = self.projects_aliases.detect{|k,v| v == al}
+    if res.present?
+      res.first.to_i
+    else
+      default_project_id
+    end
+  end
+
+  # parse number 
+  # f1234 -> [project_id, 1234]
+  # p1235 -> [project_id, 1235]
+  # 1235  -> [default_project_id, 1235]
+  def parse_number(entered_number)
+    entered_number.to_s =~ /(.*?)([0-9]+)/i
+    prj = $1.to_s
+    num = $2.to_s
+
+    if prj.blank?
+      [default_project_id, num.to_i]
+    else
+      [find_project_id_by_alias(prj), num.to_i]
+    end
+  end
+ 
+  # === Methods ===
+
+  # find persons by regexp, if blank than find me
+  def find_persons(regx = "")
+    return nil if regx.nil?
+
+    res = []
+    if regx == ""
+      return [me_id]
+    else
+      regx = enc_cmd(regx)
+      res = people.select{|id, login| login.mb_chars.downcase =~ /#{regx.mb_chars.strip.downcase}/i}
+    end
+
+    if !res.empty?
+      res.map &:first
+    else
+      say "no peoples matched #{regx}"
+      []
+    end
+  end
+
+  def show_projects #!
+    projects = Unfuzzle.projects
+
+    say "    ", nil, false
+    say "id".ljust(10), nil, false
+    say "name".ljust(20), nil, false
+    say 'title'.ljust(20), nil, false
+    say "disk-usage".ljust(20), nil, false
+    say "alias"
+
+    projects.each do |project|
+      say project.id.to_i == self.default_project_id ? "  * " : "    ", nil, false
+      say project.id.to_s.ljust(10), :yellow, false
+      say project.slug.ljust(20), :green, false
+      say project.name.ljust(20), nil, false
+      say project.disk_usage.to_s.ljust(20), nil, false
+      say projects_aliases[project.id].to_s
+    end
+  end
+
+  # Ticket Heads
+
+  def render_ticket_head(ticket)
+    color = color(ticket.priority)
+    say number_with_a(ticket).to_s.ljust(9), :yellow, false
+    say ticket.title.mb_chars[0..60].ljust(65), color, false
+    say ticket.status.ljust(14), color, false
+    say people[ticket.reporter_id].to_s.mb_chars.ljust(15), color, false
+    say people[ticket.assignee_id].to_s.mb_chars.ljust(15), color, false
+    say ticket.hours.to_s, color, true
+  end
+  
+  def render_ticket_heads(tickets)
+    groups = {}
+    tickets.each do |ticket|
+      groups[ticket.status] ||= []
+      groups[ticket.status] << ticket
+    end
+    
+    groups.each do |group, tickets|
+      tickets = tickets.sort_by{|t| t.number.to_i}
+      tickets.each{|ticket| render_ticket_head(ticket) }
+      say ''
+    end
+  end
+
+  def render_ticket_heads_by_people(t)
+    groups = {}
+    t.each do |ticket|
+      groups[ticket.assignee_id] ||= []
+      groups[ticket.assignee_id] << ticket
+    end
+
+    groups.each do |ass_id, tickets|
+      say "============== #{people[ass_id].to_s.mb_chars} ================ (#{tickets.size}) tickets", :on_red, true
+      render_ticket_heads tickets
+      say ''
+    end
+  end
+
+  def render_ticket_heads_by_project(t)
+    groups = {}
+    t.each do |ticket|
+      groups[ticket.project_id] ||= []
+      groups[ticket.project_id] << ticket
+    end
+
+    groups.each do |project_id, tickets|
+      say "Project => #{cached_projects[project_id]}: ", :yellow, true
+      render_ticket_heads_by_people tickets
+      say ''
+    end
+  end
+
+  def show_all_active_tickets(name = nil, all_projects = false) #!
+    ass_ids = find_persons(name == "" ? nil : name) || []
+    t = Unfuzzle::Ticket.all_by_dinamic_report(all_projects ? nil : [default_project_id], false)
+    t.reject!{|ticket| !ass_ids.blank? && !ass_ids.include?(ticket.assignee_id) }
+    render_ticket_heads_by_project t
+  end  
+  
+  def show_my_tickets(all_projects = false) #!
+    t = Unfuzzle::Ticket.all_by_dinamic_report(all_projects ? nil : [default_project_id], true)
+    render_ticket_heads_by_project t
+  end
+
+  # TimeEntry
+
+  def render_times(times, sum_only = false)
+    times = times.sort_by{|t| t.date.to_s }
+
+    sum = 0
+    title_present = false
+
+    times.each do |time|
+      unless sum_only
+        #say time.ticket_id.to_s.ljust(8), :yellow, false
+        title_present = true if time.title.present?
+        say time.title.to_s.mb_chars[0..30].ljust(34), :yellow, false if title_present
+        say time.description.mb_chars[0..50].ljust(54), nil, false
+        say (time.hours.to_s + " h.").ljust(9), nil, false
+        say people[time.person_id].to_s.mb_chars.ljust(13), nil, false
+        say time.date, nil
+      end
+      
+      sum += time.hours.to_f      
+    end
+    
+    say ''.ljust(34), nil, false if title_present
+    say ''.ljust(54), nil, false
+    say (sum.to_s + " h.").ljust(10), :red, true
+    
+    sum
+  end
+  
+  def render_people_times(times, sum_only = false)
+    groups = {}
+    times.each do |time|
+      groups[time.person_id] ||= []
+      groups[time.person_id] << time
+    end
+    
+    groups.each do |group, times|
+      say "============== #{people[group].to_s.mb_chars} ================", :on_red, true
+      render_times(times, sum_only)
+      say ''
+    end
+  end
+
+  def filter_times(times, for_id = nil)
+    times.select do |time|
+      time.person_id == for_id
+    end
+  end
+
+  def times_report(me = false, period = 0, sum_only=false)
+    p = periods(period)
+    t = Unfuzzle::TimeEntry.time_invested(default_project_id, p.at(0), p.at(1))
+    t = filter_times(t, me_id) if me
+    render_people_times(t, sum_only)
+  end
+
+  def all_times_report(me = false, period = 0, sum_only=false)
+    p = periods(period)
+    t = Unfuzzle::TimeEntry.all_time_invested(p.at(0), p.at(1))
+    t = filter_times(t, me_id) if me
+    render_people_times(t, sum_only)
+  end
+
+  def periods(period)
+    case period
+      when 'ty' then [Time.now.beginning_of_year, Time.now]
+      when 'ly' then [(Time.now.beginning_of_year-1.seconds).beginning_of_year, (Time.now.beginning_of_year-1.seconds)]
+      when 'tm' then [Time.now.beginning_of_month, Time.now]
+      when 'lm' then [(Time.now.beginning_of_month-1.seconds).beginning_of_month, (Time.now.beginning_of_month-1.seconds)]
+      when 'tw' then [Time.now.beginning_of_week, Time.now]
+      when 'lw' then [(Time.now.beginning_of_week-1.seconds).beginning_of_week, (Time.now.beginning_of_week-1.seconds)]
+      when 'y' then [(Time.new - 1.day).beginning_of_day, ((Time.new - 1.day).end_of_day)]
+      else [Time.now - period.to_i.days, Time.now]
+    end
+  end
+
+  # Ticket
+
+  def render_comment(cm)
+    say people[cm.author_id].to_s.mb_chars, :on_blue, false
+    say "  " + cm.created_at.to_s, nil, true
+    say cm.body.mb_chars, nil, true
+  end
+
+  def render_ticket(t, comments = [], time_entries = [])
+    color = color(t.priority)
+
+    say number_with_a(t).to_s, :on_red
+    say t.title.to_s.mb_chars, :on_blue
+    say cached_projects[t.project_id].to_s, color, true
+    say t.status, color
+    say t.priority_name, color    
+    say people[t.reporter_id].to_s + " => " + people[t.assignee_id].to_s, color, true
+    say t.description.to_s.mb_chars, color, true
+    say t.hours.to_s + " h.", color
+
+    if !time_entries.blank?
+      say ''
+      say "Time Entries: ", :blue, true
+      render_times(time_entries)
+    end
+
+    if !comments.blank?
+      say ''
+      say 'Comments: ', :on_red, true
+      comments.each{|cm| render_comment(cm) }
+    end
+  end
+
+  def show_ticket(num, opt)
+    prj, number = parse_number(num)
+    t, cm = Unfuzzle::Ticket.find_first_by_project_id_and_number_with_comments(prj, number)
+    times = (opt == "t") ? Unfuzzle::TimeEntry.all_for_ticket(t) : []
+    render_ticket(t, cm, times)
+  end
+
+  def open_ticket_in_browser(num)
+    prj, number = parse_number(num)
+    url = "https://#{Unfuzzle.subdomain}.unfuddle.com/a#/projects/#{prj}/tickets/by_number/#{number}"
+    if(WIN)
+      system("start #{url}")
+    elsif(MAC)
+      system("open #{url}")
+    else
+      system("xdg-open #{url}")
+    end
+  end
+
+  # 
+  def update_tickets(tickets, new_status)
+    tickets = tickets.split(",").map &:strip
+    if !tickets.blank? && !new_status.blank?
+      ts = tickets.map{|num| 
+        prj, number = parse_number(num)
+        Unfuzzle::Ticket.find_first_by_project_id_and_number(prj, number) rescue nil 
+      }.compact
+      say "Update tickets #{ts.map(&:number) * ','} to status #{new_status}"
+
+      ts.each do |t|
+        t.status = new_status
+        t.update
+        render_ticket(t)
+      end
+    else
+      say "no one tickets"
+    end
+  end
+  
+  def update_tickets_assignee(tickets, new_assignee)
+    tickets = tickets.split(",").map &:strip
+    if !tickets.blank?
+      ts = tickets.map{|num| 
+        prj, number = parse_number(num)
+        Unfuzzle::Ticket.find_first_by_project_id_and_number(prj, number) rescue nil 
+      }.compact
+ 
+      # find person
+      ass_ids = find_persons(new_assignee)
+      exit 1 if ass_ids.size < 1
+
+      person = people[ass_ids.first]
+
+      say "Update tickets #{ts.map(&:number) * ','} to assignee #{person}"
+
+      ts.each do |t|
+        t.assignee_id = ass_ids.first
+        t.update
+        render_ticket(t)
+      end
+    else
+      say "no one tickets"
+    end
+  end
+  
+  def new_ticket(title, assignee = "", priority = 3)
+    # find user
+    ass_id = find_persons(assignee).first
+
+    prio = priority.blank? ? 3 : priority.to_i
+
+    t = Unfuzzle::Ticket.new
+    t.title = enc_cmd(title)
+    t.assignee_id = ass_id
+    t.reporter_id = find_persons.first # me
+    t.priority = prio
+    t.project_id = default_project_id
+
+    say "Now enter description"    
+    t.description = read_text
+
+    say "Create ticket: ", nil, true
+    say t.title, nil, true
+    say t.description, nil, true
+    say people[t.assignee_id]
+    say ''
+
+    t.create
+    render_ticket(t)
+  end
+
+  def add_comment(number)
+    prj, number = parse_number(number)
+    t, cms = Unfuzzle::Ticket.find_first_by_project_id_and_number_with_comments(prj, number)
+    
+    say "Enter body of comment: ", :red, true
+    text = read_text
+    
+    cm = Unfuzzle::Comment.new
+    cm.body = text
+    cm.author_id = me_id
+    
+    cm.create(t.project_id, t.id)
+    
+    cms += [cm]
+    
+    render_ticket(t, cms)
+  end
+
+  def add_time(number, hours, comment = "", date = "")
+    prj, number = parse_number(number)
+    t, cms = Unfuzzle::Ticket.find_first_by_project_id_and_number_with_comments(prj, number)
+    
+    time = Unfuzzle::TimeEntry.new
+    time.description = enc_cmd(comment)
+    time.hours = hours
+    time.ticket_id = t.id
+    time.date = date.blank? ?  Time.now.strftime("%Y-%m-%d") : date
+    time.person_id = me_id
+    
+    time.create(t.project_id, t.id)
+
+    times = Unfuzzle::TimeEntry.all_for_ticket(t)
+    
+    t.hours = (t.hours.to_f + time.hours.to_f).to_s
+    render_ticket(t, cms, times)
+  end
+
+  def set_current(number)
+    if cached_projects.keys.include?(number.to_i)
+      self.default_project_id = number.to_i
+      set_config
+      say "set current project to #{number}"
+      say ''
+      show_projects
+    elsif projects_aliases.values.include?(number.to_s) # alias?
+      self.default_project_id = projects_aliases.detect{|k,v| v == number.to_s}.first rescue self.default_project_id
+      set_config
+      say "set current project to #{number}"
+      say ''
+      show_projects      
+    else
+      say "bad number #{number}, should be in #{cached_projects.keys.inspect}"
+    end
+  end
+
+  def set_alias(number, _alias)
+    if cached_projects.keys.include?(number.to_i)
+      self.projects_aliases[number.to_i] = _alias
+      set_config
+      say "set project #{number} alias to #{_alias}"
+      say
+      show_projects
+    else
+      say "bad number #{number}, should be in #{cached_projects.keys.inspect}"
+    end
+  end
+
+  def notify_periodic(params = '')
+    t = Unfuzzle::Ticket.all_by_dinamic_report(nil, true).map(&:to_hash)
+
+    # options
+    show_new = true # показывать новые созданные тикеты
+    show_statuses = true # показывать изменения статусов тикетов
+    show_closed = true # показывать какие были закрыты
+    all_tickets = true # учитывать ли все тикеты (не только привязанные ко мне)
+    my_tickets = true # делать нотификацию только тикетов которые созданы мной или на меня
+    all_projects = true # тикеты брать со всех проектов или с текущего
+
+    params = [show_new,show_statuses,show_closed,all_tickets,my_tickets,all_projects]
+
+    t = Unfuzzle::Ticket.all_by_dinamic_report(all_projects ? nil : [default_project_id], !all_tickets).map(&:to_hash)
+
+    cached = cached_tickets(params)
+
+    if cached.size == 0
+      say "first time: caching ..."
+      set_cached_tickets(t, params)
+      return
+    end
+
+    if my_tickets
+      cached = cached.select{|c| c['assignee-id'] == me_id || c['reporter-id'] == me_id }
+      t = t.select{|c| c['assignee-id'] == me_id || c['reporter-id'] == me_id }
+    end
+
+    cached_h = {}
+    t_h = {}
+
+    # into hash
+    cached.each{|c| k = [c['project-id'], c['number']]; cached_h[k] = c }
+    t.each{|c| k = [c['project-id'], c['number']]; t_h[k] = c }
+
+
+    message = []
+
+    # new tickets
+    if show_new && (t_h.keys - cached_h.keys).present?
+      (t_h.keys - cached_h.keys).each{|key| message << "New ticket #{number_with_a_by_params(key[0], key[1])}: '#{t_h[key]['summary']}'"}
+    end
+
+    # change status tickets
+    chanched = []
+    t_h.each{|key, value| chanched << key if cached_h[key] && value['status'] != cached_h[key]['status']}
+
+    if show_statuses && chanched.present?
+      chanched.each{|key| message << "#{number_with_a_by_params(key[0], key[1])}: '#{t_h[key]['summary']}' =>  #{t_h[key]['status']}"}
+    end
+
+    # closed tickets
+    if show_closed && (cached_h.keys - t_h.keys).present?
+      (cached_h.keys - t_h.keys).each{|key| message << "Closed ticket #{number_with_a_by_params(key[0], key[1])}: '#{cached_h[key]['summary']}'"}
+    end
+
+    message = message * "\n"
+    notify_message(message)
+
+    set_cached_tickets(t, params)
+  end
+
+  def notify_message(message)
+    return if message.empty?
+    if WIN
+      say message
+
+    elsif MAC
+      system("growlnotify --name 'confuddle' -s -m '#{message}'")
+
+    else
+      system("dbus-launch notify-send -t 5000 \"Unfuddle notification\" \"#{message}\"")
+    end
+  end
+
+public
+
+  desc "projects", "show all projects for your account"
+  def projects
+    show_projects
+  end
+
+  desc "all [REGEXP]", "show all tickets for current project"
+  def all(regexp = "")
+    show_all_active_tickets(regexp)
+  end
+
+  desc "my", "show tickets assignee to me for current project"
+  def my
+    show_my_tickets
+  end
+
+  desc "alla [REGEXP]", "show all (in all projects) tickets"
+  def alla(regexp = "")
+    show_all_active_tickets(regexp, true)
+  end
+
+  desc "mya", "show tickets (in all projects) assignee to me"
+  def mya
+    show_my_tickets true
+  end
+
+  desc "show NUMBER [t]", "show ticket by number, [t] - show TimeEntries"
+  def show(number, opt = "")
+    show_ticket(number, opt)
+  end
+
+  # Upd
+  desc "upd TICKETS NEW_STATUS", "update tickets statuses"
+  def upd(tickets, new_status)
+    update_tickets(tickets, new_status)
+  end
+
+  desc "assi TICKETS [NEW_ASSIGNEE]", "update tickets assingee"
+  def assi(tickets, new_assignee = "")
+    update_tickets_assignee(tickets, new_assignee)
+  end
+
+  desc "clear", "clear caches"
+  def clear
+    require 'fileutils'
+    FileUtils.rm(CACHED_PEOPLE) rescue nil
+    FileUtils.rm(CACHED_PROJECTS) rescue nil
+    say "cached cleared"
+  end
+
+  # Times
+  desc "tm PERIOD", "show my times report (PERIOD = [tm lm tw lw y [0-9]+])"
+  def tm(period = 0, sum_only='')
+    times_report(true, period, sum_only == 's')
+  end
+
+  desc "t PERIOD", "show all times report (PERIOD = [tm lm tw lw y [0-9]+])"
+  def t(period = 0, sum_only='')
+    times_report(false, period, sum_only == 's')
+  end
+
+  desc "atm PERIOD", "show my times report for account (PERIOD = [tm lm tw lw y [0-9]+])"
+  def atm(period = 0, sum_only='')
+    all_times_report(true, period, sum_only == 's')
+  end
+
+  desc "at PERIOD", "show all times report for account (PERIOD = [tm lm tw lw y [0-9]+])"
+  def at(period = 0, sum_only='')
+    all_times_report(false, period, sum_only == 's')
+  end
+
+  # Add
+  desc "addt NUMBER HOURS COMMENT [DATE]", "add time"
+  def addt(ticket_number, hours, comment, date = nil)
+    add_time(ticket_number, hours, comment, date)
+  end
+
+  desc "addcm NUMBER", "add ticket comment"
+  def addcm(ticket_number)
+    add_comment(ticket_number)
+  end
+
+  desc "new TITLE [ASSIGNEE] [PRIO]", "create ticket"
+  def new(title, assignee = "", priority = 3)
+    new_ticket(title, assignee, priority)
+  end
+
+  desc "curr ID_OR_ALIAS", "set current project id"
+  def curr(current)
+    set_current(current)
+  end
+
+  desc "alias PROJECT_ID ALIAS", "set project alias"
+  def alias(project_id, _alias)
+    set_alias(project_id, _alias)
+  end
+
+  desc "op TICKET_ID", "Open selected ticked from current project in browser"
+  def op(ticket_id)
+    open_ticket_in_browser(ticket_id)
+  end
+
+  desc "notify PARAMS", "Notify about changes with tickets by Gnome-Notify, PARAMS='status,comments'"
+  def notify(params = '')
+    notify_periodic params
+  end
+  
+  desc "install", "copy sample config into home"
+  def install
+    require 'fileutils'
+    file = File.expand_path(File.join(File.dirname(__FILE__), %w(.. .passwd_to_unfuddle.example.yml) ))
+    FileUtils.cp(file, PASS_FILE)
+    say("Config copyed!", :green)
+    say("Edit file #{PASS_FILE}!", :red)
+  end
+
+  default_task(:my) # by default
+end
+
+Unfuddle.start