ascii_invoicer 2.5.5

data/lib/ascii_invoicer/generators.rb

@@ -0,0 +1,209 @@
+module Generators
+  def generate_hours_total full_data
+    hours = full_data[:hours]
+    hours[:salary] * hours[:time]
+  end
+
+  def generate_hours_time full_data
+    hours = full_data[:hours]
+    sum = 0
+    if hours[:caterers]
+      hours[:caterers].values.each{|v| sum += v.rationalize}
+      return sum.to_f
+    elsif hours[:time]
+      fail_at :caterers
+      return hours[:time]
+    end
+    sum
+  end
+
+  def generate_client_fullname full_data
+    client = full_data[:client]
+    fail_at :client_first_name unless client[:first_name]
+    fail_at :client_last_name unless client[:last_name]
+    return fail_at :client_fullname unless client[:first_name] and client[:last_name]
+    return [client[:first_name], client[:last_name]].join ' '
+  end
+
+  def generate_client_addressing full_data
+    return fail_at(:client_addressing) unless full_data[:client]
+    return fail_at(:client_title) unless full_data[:client][:title]
+    lang       = full_data[:lang]
+    client     = full_data[:client]
+    title      = client[:title].words.first.downcase
+    gender     = @settings['gender_matches'][title]
+    addressing = @settings['lang_addressing'][lang][gender]
+    return "#{addressing} #{client[:title]} #{client[:last_name]}"
+  end
+
+  def generate_caterers full_data
+    caterers = []
+    full_data[:hours][:caterers].each{|name, time| caterers.push name} if full_data[:hours][:caterers]
+    return caterers
+  end
+
+  def generate_event_date full_data
+    Date.parse full_data[:event][:dates][0][:begin]  unless full_data[:event][:dates].nil?
+  end
+
+  def generate_event_calendaritems full_data
+    begin
+      events = []
+      full_data[:event][:dates].each { |date|
+        # TODO event times is not implemented right
+        unless date[:times].nil?
+
+          ## set specific times
+          date[:times].each { |time|
+            if time[:end]
+              dtstart = DateTime.parse( date[:begin].strftime("%d.%m.%Y ") + time[:begin] )
+              dtend   = DateTime.parse( date[:begin].strftime("%d.%m.%Y ") + time[:end] )
+            else
+              dtstart = Icalendar::Values::Date.new( date[:begin].strftime  "%Y%m%d")
+              dtend   = Icalendar::Values::Date.new((date[:end]+1).strftime "%Y%m%d")
+            end
+            event = Icalendar::Event.new
+            event.dtstart = dtstart
+            event.dtend   = dtend
+            events.push  event unless event.dtstart.nil?
+
+          }
+
+        else
+          ## set full day event
+          event = Icalendar::Event.new
+          event.dtstart = Icalendar::Values::Date.new( date[:begin].strftime  "%Y%m%d")
+          event.dtend   = Icalendar::Values::Date.new((date[:end]+1).strftime "%Y%m%d")
+          events.push  event unless event.dtstart.nil?
+
+        end
+
+        events.each{ | event|
+
+          event.description = ""
+          event.summary     = full_data[:event][:name]
+          event.summary  = "CANCELED: #{ event.summary }" if full_data[:canceled]
+
+          event.description += "Verantwortung: " + full_data[:manager]      + "\n" if full_data[:manager]
+          if full_data[:hours][:caterers]
+            event.description +=  "Caterer:\n"
+            full_data[:caterers].each {|caterer,time| event.description +=  " - #{ caterer}\n" }
+          end
+
+          event.description += full_data[:description]  + "\n" if full_data[:description]
+        }
+      }
+      return events
+    rescue
+      @errors << :event_dates
+      return false
+    end
+  end
+
+  def generate_productsbytax full_data
+    list = {}
+    taxlist = {}
+    full_data[:products].each {|product|
+      list[product.tax_value] = [] unless list[product.tax_value]
+      list[product.tax_value] << product
+    }
+    list.keys.sort.each{|key| taxlist[key] = list[key] } # sorting a hash by keys
+    return taxlist
+  end
+
+  def generate_event_age full_data
+    (Date.today - full_data[:event][:date]).to_i
+  end
+
+  def sum_money key
+    sum = 0.to_euro
+    @data[:products].each{|p| sum += p.hash[key]} if @data[:products].class == Array
+    sum.to_euro
+  end
+
+  def generate_event_date full_data
+    full_data[:event][:dates][0][:begin] unless full_data[:event][:dates].nil?
+  end
+
+  def generate_event_prettydate full_data
+    return fail_at :event_prettydate if full_data[:event][:dates].nil?
+    date = full_data[:event][:dates][0]
+    first = date[:begin]
+    last = full_data[:event][:dates].last[:end]
+    last = full_data[:event][:dates].last[:begin] if last.nil?
+
+    return "#{first.strftime "%d"}-#{last.strftime "%d.%m.%Y"}" if first != last
+    return first.strftime "%d.%m.%Y" if first.class == Date
+    return first
+  end
+
+  def generate_offer_number full_data
+    appendix  = full_data[:offer][:appendix]
+    full_data[:offer][:date].strftime "A%Y%m%d-#{appendix}"
+  end
+
+
+  # costs: price of all products summed up
+  # taxes: price of all products taxes summed up ( e.g. price*0.19 )
+  # total: costs + taxes
+  # final: total + salary * hours
+
+
+  def generate_offer_costs full_data
+    sum_money :cost_offer
+  end
+
+  def generate_offer_taxes full_data
+    sum_money :tax_offer
+  end
+
+  def generate_offer_total full_data
+    sum_money :total_offer
+  end
+
+  def generate_offer_final full_data
+    full_data[:offer][:total] + full_data[:hours][:total]
+  end
+
+
+
+
+  def generate_invoice_costs full_data
+    sum_money :cost_invoice
+  end
+
+  def generate_invoice_taxes full_data
+    sum_money :tax_invoice
+  end
+
+  def generate_invoice_total full_data
+    sum_money :total_invoice
+  end
+
+  def generate_invoice_final full_data
+    full_data[:invoice][:total] + full_data[:hours][:total]
+  end
+
+  def generate_invoice_delay full_data
+    return 0 if full_data[:canceled]
+    return -(full_data[:event][:date] - full_data[:invoice][:date] if full_data[:invoice][:date]).to_i
+    return -(full_data[:event][:date] - Date.today).to_i
+  end
+
+  def generate_invoice_paydelay full_data
+    if full_data[:invoice][:payed_date] and full_data[:invoice][:date]
+      delay = full_data[:invoice][:payed_date] - full_data[:invoice][:date]
+      fail_at :invoice_payed if delay < 0
+      return delay.to_i
+    end
+    return nil
+  end
+
+  def generate_invoice_longnumber full_data
+    if full_data[:invoice][:date]
+      year = full_data[:invoice][:date].year
+      full_data[:invoice][:number].gsub /^R/, "R#{year}-" if full_data[:invoice][:number]
+    end
+  end
+
+end

data/lib/ascii_invoicer/hash_transformer.rb

@@ -0,0 +1,23 @@
+require 'hash-graft'
+
+class HashTransformer
+  attr_reader :original_hash, :new_hash
+  attr_writer :rules
+
+  def initialize(hash = {})
+    @original_hash = hash[:original_hash]
+    @original_hash ||= {}
+    @new_hash = {}
+    @rules = hash[:rules]
+    @rules ||= []
+  end
+
+  def transform
+    @new_hash = @original_hash
+    @rules.each {|rule|
+      @new_hash.set_path(rule[:new],  @original_hash.get_path(rule[:old]))
+    }
+    return @new_hash
+  end
+
+end

data/lib/ascii_invoicer/mixins.rb

@@ -0,0 +1,268 @@
+require 'icalendar'
+require 'fileutils'
+
+module AsciiMixins
+
+  ## Use Option parser or leave it if only one argument is given
+
+  def render_project project, choice
+    project.validate choice
+    if project.valid_for[choice]
+      project.create_tex choice, options[:check]
+    else
+      $logger.error "#{project.name} is not ready for creating an #{choice.to_s}! #{project.data[:valid]} #{project.errors if project.errors.length > 0}"
+    end
+  end
+
+  ##TODO turn color_from_date(date) into a loopuk into $SETTINGS
+  def color_from_date(date)
+    diff = date - Date.today
+    return (rand * 256**3).to_i.to_s(16) if Date.today.day == 1 and Date.today.month == 4 #april fools
+    return :magenta                      if diff < -28
+    return :cyan                         if diff < 0
+    return [:yellow,:bright]             if diff == 0
+    return :red                          if diff < 7
+    return :yellow                       if diff < 14
+    return [:green]
+  end
+
+  def print_project_list projects, hash = {}
+    table = Textboxes.new
+    table.style[:border]             = false
+    table.style[:column_borders]     = false
+    table.style[:row_borders]        = false
+    table.style[:padding_horizontal] = 1
+    projects.each_index do |i|
+      project  = projects[i]
+      if !hash[:colors].nil? and hash[:colors]
+        color = color_from_date(project.date)
+        color = :default if project.validate(:invoice)
+        color = [:blue] if project.status == :canceled
+      end
+      if hash[:verbose]
+        row = print_row_verbose project, hash
+      else
+        row = print_row_simple project, hash
+      end
+
+      row << project.data[:hours][:caterers].keys.join(", ") if hash[:caterers] and project.data[:hours][:caterers]
+
+      row << project.blockers(:archive)      if hash[:blockers]
+      if hash[:details]
+        hash[:details].each {|detail|
+          row << project.data.get_path(detail)
+        }
+      end
+
+      row << project.errors                  if hash[:errors] and project.status == :ok
+      row << project.status                  if hash[:errors] and project.status == :canceled
+      row.insert 0, i+1
+      table.add_row row, color
+    end
+    table.set_alignments(:r, :l, :l)
+    puts table
+  end
+
+  def print_row_simple(project,hash) 
+    row = [
+      project.pretty_name,
+      project.data[:manager],
+      project.data[:event][:invoice_number],
+      project.data[:event][:date].strftime("%d.%m.%Y"),
+      #project.index
+    ]
+    return row
+  end
+
+  def print_row_verbose (project, hash)
+    name = "##{project.data[:name]}#"
+    if not project.data[:event][:name].nil? and project.data[:event][:name].size > 0
+      name = project.data[:event][:name]
+      name = "CANCELED: " + name if project.data :canceled
+    end
+    row = [
+      name,
+      project.data[:manager],
+      project.data[:invoice][:number],
+      project.date.strftime("%d.%m.%Y"),
+      project.validate(:offer).print,
+      project.validate(:invoice).print,
+      project.validate(:payed).print($SETTINGS.currency_symbol),
+      # try these: ☑☒✉☕☀☻
+    ]
+    return row
+  end
+
+  def print_project_list_paths(projects)
+    table = Textboxes.new
+    projects.each_index do |i|
+      p  = projects[i]
+      table.add_row [
+        (i+1).to_s+".", 
+        p.name.ljust(35), 
+        p.data[:project_path]
+      ]
+    end
+    table.set_alignments(:r, :l, :l)
+    puts table
+  end
+
+  def create_cal_file(projects)
+    cal = Icalendar::Calendar.new
+    projects.each_index do |i|
+      project = projects[i]
+      events = project.data[:event][:calendaritems]
+      if events
+        events.each { |event| cal.add_event event}
+      else
+        $logger.warn "Calendar can't be parsed. (#{project.data[:name]})", :file
+      end
+    end
+
+    cal_file_path = File.join(FileUtils.pwd, $SETTINGS.calendar_file)
+    cal_file = File.open(cal_file_path, ?w)
+    cal_file.write cal.to_ical
+    puts "created #{cal_file_path}"
+  end
+
+  #takes an array of invoices (@plumber.working_projects)
+  def print_project_list_yaml(projects)
+    projects.each do |p|
+      puts p.data.to_yaml
+      puts "...\n\n"
+    end
+  end
+  
+  def caterers_string project, join = ", "
+      data = project.data
+      data[:hours][:caterers].map{|name, hours| "#{name} (#{hours})" if hours > 0 }.join join if data[:hours][:caterers]
+  end
+
+  #takes an array of invoices (@plumber.working_projects)
+  def print_project_list_csv(projects)
+    header = [
+      'Rnum',
+      'Bezeichnung',
+      'Datum',
+      'Rechnungsdatum',
+      'Betreuer',
+      'verantwortlich',
+      'Bezahlt am',
+      'Betrag',
+      'Canceled',
+    ]
+    puts header.to_csv(col_sep:";")
+    projects.each do |p|
+      canceled = ""
+      canceled = "canceled" if p.data[:canceled]
+      line = [
+        p.data[:invoice][:number],
+        p.data[:event][:name],
+        p.data[:event][:date],
+        p.data[:invoice][:date],
+        caterers_string(p),
+        p.data[:manager].words[0],
+        p.data[:invoice][:payed_date],
+        p.data[:invoice][:final],
+        canceled,
+        #  p.valid_for[:invoice]
+      ]
+      canceled = "canceled" if p.data[:canceled]
+      line.map! {|v| v ? v : "" } # wow, that looks cryptic
+      puts line.to_csv(col_sep:";")
+    end
+  end
+
+  def display_products project, choice = :offer, standalone = true
+    table = Textboxes.new
+    table.style[:border] = standalone
+    table.title = "Project:" + "\"#{project.data[:event][:name]}\"".rjust(25) if standalone
+    table.add_row ["#", "name", "price", "cost"]
+    table.set_alignments :r, :l, :r, :r
+    project.data[:products].each {|product|
+      amount = product.amount choice
+      price = product.price
+      cost  = product.cost choice
+      table.add_row [amount, product.name, price, cost]
+    }
+    table.add_row ["#{project.data[:hours][:time]}h", "service" , project.data[:hours][:salary], project.data[:hours][:total]] if project.data.get_path('hours/time').to_i> 0
+    table.add_row [nil, caterers_string(project)]
+
+    return table
+  end
+
+  def display_all project, choice, show_errors = true
+    raise "choice must be either :invoice or :offer" unless choice == :invoice or choice == :offer
+    data = project.data
+
+    table = Textboxes.new
+    table.style[:border] = true
+    table.title = "Project:" + "\"#{data[:event][:name]}\"".rjust(25)
+    table.add_row [nil, "name", "amount","price", "cost"]
+    table.set_alignments :r, :l, :r, :r, :r
+
+    i = 0
+    data[:products].each {|product|
+      amount = product.amount choice
+      price = product.price
+      cost  = product.cost choice
+      table.add_row [i+=1,product.name, amount, price, cost]
+    }
+    table.add_row [i+1,"service", "#{data[:hours][:time]}h",  data[:hours][:salary], data[:hours][:total]] if project.data.get_path('hours/time').to_i> 0
+
+    separator = table.column_widths.map{|w| ?=*w}
+    separator[0] = nil
+    table.add_row separator
+
+    table.add_row  [nil,"Kosten",nil,nil,"#{data[choice][:costs]}"]
+    data[:productsbytax].each {|tax,products|
+      tpv = 0.to_euro # tax per value
+      tax = (tax.rationalize * 100).to_f
+      products.each{|p|
+        tpv += p.hash[:tax_offer]   if choice == :offer
+        tpv += p.hash[:tax_invoice] if choice == :invoice
+      }
+      table.add_row  [nil, "MWST #{tax}%",nil,nil,"#{tpv}"]
+    }
+    table.add_row   [nil,  "Final", nil, nil, "#{data[choice][:final]}"]
+
+    if show_errors
+      table.footer = "Errors: #{project.errors.length} (#{ project.errors.join ',' })" if project.errors.length >0
+    end
+
+    return table
+  end
+
+  def display_products_csv project
+    puts [['name', 'price', 'amount', 'sold', 'tax_value'].to_csv(col_sep:?;)]+
+    project.data[:products].map{|p| p.to_csv(col_sep:?;)}
+  end
+
+  def check_project(path)
+    project = InvoiceProject.new $SETTINGS
+    project.open path
+    unless project.validate(:offer)
+      puts "\nWARNING: the file you just edited contains errors! (#{project.errors})"
+      unless no? "would you like to edit it again? [y|N]"
+        edit_files path
+      end
+    end
+  end
+
+  ## hand path to editor
+  def edit_files(paths, editor = $SETTINGS.editor)
+    paths = [paths] if paths.class == String
+    paths.select! {|path| path}
+    if paths.empty?
+      $logger.error "no paths to open"
+      return false
+    end
+    paths.map!{|path| "\"#{path}\"" }
+    paths = paths.join ' '
+    editor = $SETTINGS.editor unless editor
+    $logger.info "Opening #{paths} in #{editor}"
+    pid = spawn "#{editor} #{paths}"
+    Process.wait pid
+  end
+
+end