rtt 0.0.0.1

data/lib/rtt/hash_extensions.rb

@@ -0,0 +1,86 @@
+
+# Hash#deep_merge
+# From: http://pastie.textmate.org/pastes/30372, Elliott Hird
+# Source: http://gemjack.com/gems/tartan-0.1.1/classes/Hash.html
+# This file contains extensions to Ruby and other useful snippits of code.
+# Time to extend Hash with some recursive merging magic.
+
+
+class Hash
+
+  # Merges self with another hash, recursively.
+  # 
+  # This code was lovingly stolen from some random gem:
+  # http://gemjack.com/gems/tartan-0.1.1/classes/Hash.html
+  # 
+  # Thanks to whoever made it.
+
+  def deep_merge(hash)
+    target = dup
+    
+    hash.keys.each do |key|
+      if hash[key].is_a? Hash and self[key].is_a? Hash
+        target[key] = target[key].deep_merge(hash[key])
+        next
+      end
+      
+      target[key] = hash[key]
+    end
+    
+    target
+  end
+
+
+  # From: http://www.gemtacular.com/gemdocs/cerberus-0.2.2/doc/classes/Hash.html
+  # File lib/cerberus/utils.rb, line 42
+
+  def deep_merge!(second)
+    second.each_pair do |k,v|
+      if self[k].is_a?(Hash) and second[k].is_a?(Hash)
+        self[k].deep_merge!(second[k])
+      else
+        self[k] = second[k]
+      end
+    end
+  end
+
+
+#-----------------
+        
+   # cf. http://subtech.g.hatena.ne.jp/cho45/20061122
+   def deep_merge2(other)
+      deep_proc = Proc.new { |k, s, o|
+         if s.kind_of?(Hash) && o.kind_of?(Hash)
+            next s.merge(o, &deep_proc)
+         end
+         next o
+      }
+      merge(other, &deep_proc)
+   end
+
+
+   def deep_merge3(second)
+
+      # From: http://www.ruby-forum.com/topic/142809
+      # Author: Stefan Rusterholz
+
+      merger = proc { |key,v1,v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2 }
+      self.merge(second, &merger)
+
+   end
+
+
+   def keep_merge(hash)
+      target = dup
+      hash.keys.each do |key|
+         if hash[key].is_a? Hash and self[key].is_a? Hash
+            target[key] = target[key].keep_merge(hash[key])
+            next
+         end
+         #target[key] = hash[key]
+         target.update(hash) { |key, *values| values.flatten.uniq }
+      end
+      target
+   end
+
+end

data/lib/rtt/project.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/ruby -w
+module Rtt
+  class Project
+    include DataMapper::Resource
+
+    DEFAULT_NAME = 'default'
+    DEFAULT_DESCRIPTION = 'Default Project'
+
+    property :id, Serial
+    property :name, String, :required => true, :unique => true, :default => DEFAULT_NAME
+    property :description, String, :default => DEFAULT_DESCRIPTION
+    property :active, Boolean, :default => false
+
+    has n, :tasks #, :through => Resource
+    has n, :users, :through => :tasks
+    belongs_to :client
+
+    before :valid?, :set_default_client
+
+    def self.default
+      first_or_create :active => true
+    end
+
+    def activate_with_client(client)
+      self.client = client
+      self.active = true
+      self.save
+      self
+    end
+
+    def set_default_client
+      self.client = Client.default if self.client.nil?
+    end
+  end
+end

data/lib/rtt/query_builder.rb

@@ -0,0 +1,22 @@
+#!/usr/bin/ruby -w
+module Rtt
+  module QueryBuilder
+    # Query among all tasks filtering based on parameters.
+    # 
+    #
+    def query options = {}
+      Task.all(rtt_build_conditions(options))
+    end
+
+    #private
+
+    def rtt_build_conditions options
+      conditions = {}
+      conditions[:start_at.gte] = Date.parse(options[:from]) if options[:from]
+      conditions[:end_at.lte] = Date.parse(options[:to]) if options[:to]
+      conditions[:project] = { :name => options[:project] } if options[:project]
+      conditions.deep_merge!({ :project => { :client => { :name => options[:client] } }}) if options[:client]
+      conditions
+    end
+  end
+end

data/lib/rtt/report_generator.rb

@@ -0,0 +1,190 @@
+#!/usr/bin/ruby -w
+module Rtt
+  module ReportGenerator
+
+    attr_accessor :data, :different_fixed
+
+    DEFAULT_FILENAME = 'rtt_report'
+    FORMATS_ACCEPTED = [ :csv, :pdf ]
+    REPORT_FIELDS = %w(Client Project Name Date Duration)
+    FIXED_FIELDS = %w(Client Project)
+    REPORT_FIELD_OUTPUT = {
+      'Client' => Proc.new { |task| task.client.name },
+      'Project' => Proc.new { |task| task.project.name },
+      'Name' => Proc.new { |task| task.name },
+      'Date' => Proc.new { |task| task.date.strftime('%m-%d-%y') },
+      'Duration' => Proc.new { |task| task.duration }
+    }
+
+    def fill_user_information(pdf)
+      pdf.cell [330, 790],
+          :text => current_user.full_name_and_nickname,
+          :width => 225, :padding => 10, :border_width => 0, :align => :right
+      pdf.cell [330, 770],
+          :text => current_user.company,
+          :width => 225, :padding => 10, :border_width => 0, :align => :right
+      pdf.cell [330, 750],
+          :text => current_user.location,
+          :width => 225, :padding => 10, :border_width => 0, :align => :right
+      pdf.cell [330, 730],
+          :text => current_user.address,
+          :width => 225, :padding => 10, :border_width => 0, :align => :right
+      pdf.cell [330, 710],
+          :text => current_user.phone,
+          :width => 225, :padding => 10, :border_width => 0, :align => :right
+      pdf.cell [330, 690],
+          :text => current_user.email,
+          :width => 225, :padding => 10, :border_width => 0, :align => :right
+      pdf.cell [330, 670],
+          :text => current_user.site,
+          :width => 225, :padding => 10, :border_width => 0, :align => :right
+    end
+
+    def fixed_fields_for_current_data
+      @fixed_fields_for_current_data ||= begin
+        calculate_fixed_fields_based_on_data
+        @data[:fixed_fields].keys + @different_fixed.keys.reject { |key| @different_fixed[key].length > 1 }
+      end
+    end
+
+    def fixed_value(field)
+      if @data[:fixed_fields].include? field
+          @data[:fixed_fields][field]
+      else
+          @different_fixed[field].first
+      end
+    end
+
+    #
+    #
+    def report options = {}
+      raise 'Argument must be a valid Hash. Checkout: rtt usage' unless options.is_a?(Hash) || options.keys.empty?
+      @different_fixed ||= FIXED_FIELDS.inject({}) { |result, key| result[key] = []; result }
+      extension = options.keys.select { |key| FORMATS_ACCEPTED.include?(key) }.first
+      path = options[extension]
+      fixed_fields = extract_fixed_fields(options)
+      fixed_fields_and_values = fixed_fields.inject({}) { |hash, key| hash[key] = options[key.downcase.to_sym]; hash }
+      @data = { :fixed_fields => fixed_fields_and_values, :rows => query(options) }
+      case extension
+        when :pdf
+          report_to_pdf path
+        when :csv
+          raise 'CSV format report not implemented yet'
+          report_to_csv path
+        else
+          raise 'Format not supported. Only csv and pdf are available for the moment.'
+      end
+
+    end
+
+    private
+
+    def calculate_total_hours_and_minutes(data)
+      data.inject([0, 0]) do |totals, task|
+        total_h, total_m = totals
+        if task[4 - fixed_fields_for_current_data.length].match(/^(\d+)h(\d+)m$/)
+          total_m += ($2.to_i % 60)
+          total_h += ($1.to_i + $2.to_i / 60)
+        end
+        [ total_h, total_m ]
+      end
+    end
+
+    def extract_fixed_fields(options)
+      # remove Duration as we can't filter by that
+      REPORT_FIELDS[0..-2].select { |field| options.include?(field.downcase.to_sym) }
+    end
+
+    def report_to_csv output_path
+      require 'fastercsv'
+    rescue LoadError
+      puts "Missing gem: Fastercsv"
+    end
+
+     def report_to_pdf output_path
+      require 'prawn'
+      require 'prawn/layout'
+      require "prawn/measurement_extensions"
+      columns = REPORT_FIELDS - fixed_fields_for_current_data
+      data = @data[:rows].map { |task| task_row_for_fields(task, columns) }
+     
+      
+      total_h, total_m = calculate_total_hours_and_minutes(data)
+      report_generator = self
+
+      pdf = Prawn::Document.new(:page_layout => :portrait,
+                     :left_margin => 10.mm,    # different
+                     :right_margin => 1.cm,    # units
+                     :top_margin => 0.1.dm,    # work
+                     :bottom_margin => 0.01.m, # well
+                     :page_size => 'A4') do
+
+        report_generator.fill_user_information(self)
+
+        move_up 140
+        font_size 16
+        text "RTT Report"
+        text "=========="
+        move_down 40
+
+
+#        text report_generator.current_user.full_name_and_nickname, :align => :right
+        #text report_generator.current_user.company, :align => :right
+        #text report_generator.current_user.email, :align => :right
+        #text report_generator.current_user.address, :align => :right
+        #text report_generator.current_user.location, :align => :right
+        #text report_generator.current_user.phone, :align => :right
+        #text report_generator.current_user.site, :align => :right
+
+        report_generator.fixed_fields_for_current_data.each do |field|
+          text "#{field}: #{report_generator.fixed_value(field)}"
+        end
+
+        move_down 50
+
+        table data,
+          :headers => columns,
+          #:position => :center,
+          :position => :left,
+          :border_width   => 1,
+          :row_colors => [ 'fafafa', 'f0f0f0' ],
+          :font_size => 12,
+          :padding => 5,
+          :align => :left
+          #:width =>  535
+          #:column_widths => { 1=> 50, 2 => 40, 3 => 30}
+
+        move_down 20
+        text "Total: #{total_h}h#{total_m}m"
+        
+        # footer
+#        page_count.times do |i|
+            #go_to_page(i+1)
+            #lazy_bounding_box([bounds.right-50, bounds.bottom + 25], :width => 50) {
+                #text "#{i+1} / #{page_count}"
+            #}.draw
+        #end
+        number_pages "Page <page> / <total>", [bounds.right - 80, 0]
+
+        render_file(output_path || DEFAULT_FILENAME)
+      end
+    rescue LoadError
+      puts "Missing gem: prawn, prawn/layout or prawn/measurement_extensions"
+    end
+
+    def calculate_fixed_fields_based_on_data
+      @data[:rows].each do |task|
+        (REPORT_FIELDS - @data[:fixed_fields].keys).each do |field|
+          value = REPORT_FIELD_OUTPUT[field].call(task)
+          @different_fixed[field] << value if FIXED_FIELDS.include?(field) && !@different_fixed[field].include?(value)
+        end
+      end
+    end
+
+    def task_row_for_fields(task, fields)
+      fields.map do |field|
+        REPORT_FIELD_OUTPUT[field].call(task)
+      end
+    end
+  end
+end

data/lib/rtt/storage.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/ruby -w
+module Rtt
+  module Storage
+
+    def init(database = :rtt)
+      DataMapper.setup(:default, {:adapter => "sqlite3", :database => File.join( File.dirname(__FILE__), '..', '..', "db/#{database.to_s}.sqlite3") })
+      migrate unless missing_tables
+      DataObjects::Sqlite3.logger = DataMapper::Logger.new(File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'log', 'sqlite3.log')), 0)
+    end
+
+    def migrate #:nodoc:
+      DataMapper.auto_migrate!
+    end
+
+    def missing_tables
+      %W(rtt_projects rtt_users rtt_clients rtt_tasks).reject { |table| DataMapper.repository.storage_exists?(table) }.empty?
+    end
+  end
+end

data/lib/rtt/task.rb

@@ -0,0 +1,136 @@
+#!/usr/bin/ruby -w
+module Rtt
+  class Task
+    include DataMapper::Resource
+
+    DEFAULT_NAME = 'Default task'
+
+    property :id, Serial
+    property :name, Text, :required => true, :default => DEFAULT_NAME
+    property :date, Date
+    property :start_at, DateTime
+    property :end_at, DateTime
+    property :active, Boolean, :default => false
+    property :accumulated_spent_time, Float, :default => 0
+
+    belongs_to :project
+    has 1, :client, :through => :project
+    belongs_to :user
+
+    before :valid?, :set_default_project
+    before :valid?, :set_default_user
+
+    def self.task(task_name)
+      base_attributes = { :name => task_name, :user => Rtt.current_user, :date => Date.today }
+      if task_name.nil?
+        existing_task = Task.first :active => true
+        if existing_task
+          existing_task
+        else
+          base_attributes.merge!(:name => DEFAULT_NAME) if task_name.blank?
+          Task.create(base_attributes)
+        end
+      elsif (existing_task = Task.first base_attributes.merge({:start_at.gte => Date.today.beginning_of_day})).present?
+        existing_task
+      else
+        Task.create(base_attributes)
+      end
+    end
+
+    def start
+      self.start_at = DateTime.now
+      self.active = true
+      save
+      self
+    end
+
+    def add_current_spent_time_to_accumulated_spent_time
+      self.accumulated_spent_time = self.accumulated_spent_time + self.time_difference_since_start_at
+    end
+
+    def clone_task(task)
+      task = Task.new
+      task.attributes = self.attributes
+      task.id = nil
+      task
+    end
+
+    def duration
+      return '-' if end_at.blank?
+      convert_to_hour_and_minutes(accumulated_spent_time)
+    end
+
+    def set_default_project
+      self.project = Project.default if self.project.nil?
+    end
+
+    def set_default_user
+      self.user = User.default if self.user.nil?
+    end
+
+    def stop
+      split_task if span_multiple_days?
+      finish
+      self
+    end
+
+    def pause
+      split_task if span_multiple_days?
+      finish(DateTime.now, true)
+      self
+    end
+
+    def time_difference_since_start_at
+      end_date_or_now = self.end_at ? self.end_at : DateTime.now
+      end_date_or_now - self.start_at
+    end
+
+    private
+
+    def convert_to_hour_and_minutes(dif)
+      hours, mins = time_diff_in_hours_and_minutes(dif)
+      "#{hours}h#{mins}m"
+    end
+
+    def finish(end_at = DateTime.now, activation = false)
+      self.end_at = end_at
+      self.date = end_at.to_date
+      self.add_current_spent_time_to_accumulated_spent_time
+      self.active = activation
+      self.save
+    end
+
+    def save_in_between_days_split(date)
+      task = clone_task(self)
+      task.start_at = date.beginning_of_day
+      end_at = date.end_of_day.to_datetime
+      task.send(:finish, end_at)
+      task.save
+    end
+
+    def save_last_task_split(date)
+      task = clone_task(self)
+      end_at = date.end_of_day.to_datetime
+      task.send(:finish, end_at)
+      task.save
+    end
+
+    def span_multiple_days?
+      self.start_at.day != Date.today.day
+    end
+
+    def split_task
+      date = Date.today - 1
+      while (date > self.start_at)
+        save_in_between_days_split(date)
+        date -= 1
+      end
+      save_last_task_split(date)
+      self.start_at = Date.today.beginning_of_day.to_datetime
+    end
+
+    def time_diff_in_hours_and_minutes(dif)
+      Date::day_fraction_to_time(dif)
+    end
+  end
+end