3263 lines
111 KiB
Ruby
3263 lines
111 KiB
Ruby
#!usr/bin/env camping
|
||
# encoding: UTF-8
|
||
#
|
||
# stoptime.rb - The Stop… Camping Time! time registration and invoicing
|
||
# application
|
||
#
|
||
# Stop… Camping Time! is Copyright © 2011 Paul van Tilburg <paul@luon.net>
|
||
#
|
||
# This program is free software; you can redistribute it and/or modify it
|
||
# under the terms of the GNU General Public License as published by the
|
||
# Free Software Foundation; either version 2 of the License, or (at your
|
||
# option) any later version.
|
||
|
||
require "action_view"
|
||
require "active_support"
|
||
require "camping"
|
||
require "camping/mab"
|
||
require "camping/ar"
|
||
require "pathname"
|
||
require "sass/plugin/rack"
|
||
|
||
Camping.goes :StopTime
|
||
|
||
unless defined? PUBLIC_DIR
|
||
# The directory with public data.
|
||
PUBLIC_DIR = Pathname.new(__FILE__).dirname.expand_path + "public"
|
||
# The directory with template data.
|
||
TEMPLATE_DIR = Pathname.new(__FILE__).dirname.expand_path + "templates"
|
||
|
||
# Set up the locales.
|
||
I18n.load_path += Dir[ File.join('locale', '*.yml') ]
|
||
|
||
# Set up SASS.
|
||
Sass::Plugin.options[:template_location] = "templates/sass"
|
||
|
||
# Set the default encodings.
|
||
if RUBY_VERSION =~ /^1\.9/
|
||
Encoding.default_external = Encoding::UTF_8
|
||
Encoding.default_internal = Encoding::UTF_8
|
||
end
|
||
|
||
# Set the default date(/time) format.
|
||
Time::DATE_FORMATS.merge!(
|
||
default: "%Y-%m-%d %H:%M",
|
||
month_and_year: "%B %Y",
|
||
date_only: "%Y-%m-%d",
|
||
time_only: "%H:%M",
|
||
day_code: "%Y%m%d")
|
||
Date::DATE_FORMATS.merge!(
|
||
default: "%Y-%m-%d",
|
||
month_and_year: "%B %Y")
|
||
end
|
||
|
||
# = The main application module
|
||
module StopTime
|
||
|
||
# The version of the application
|
||
VERSION = '1.17.1'
|
||
puts "Starting Stop… Camping Time! version #{VERSION}"
|
||
|
||
# @return [Hash{String=>Object}] The parsed configuration.
|
||
attr_reader :config
|
||
|
||
# Overrides controller call handler so that the configuration is available
|
||
# for all controllers and views.
|
||
def service(*a)
|
||
@config = StopTime::Models::Config.instance
|
||
@format = @request.path_info[/.([^.]+)/, 1];
|
||
@headers["Content-Type"] = "text/html; charset=utf-8"
|
||
super(*a)
|
||
end
|
||
|
||
# Trap the HUP signal and reload the configuration.
|
||
Signal.trap("HUP") do
|
||
$stderr.puts "I: caught signal HUP, reloading config"
|
||
Models::Config.instance.reload
|
||
end
|
||
|
||
# Add support for PUT and DELETE.
|
||
use Rack::MethodOverride
|
||
|
||
# Enable SASS CSS generation from templates/sass.
|
||
use Sass::Plugin::Rack
|
||
|
||
# Create/migrate the database when needed.
|
||
# @return [void]
|
||
def self.create
|
||
StopTime::Models.create_schema
|
||
end
|
||
|
||
end # module StopTime
|
||
|
||
# = The Stop… Camping Time! Markaby extensions
|
||
module StopTime::Mab
|
||
|
||
# List of support methods supported by the server.
|
||
SUPPORTED = [:get, :post]
|
||
|
||
# When a tag is completed (i.e. closed), perform some post-processing
|
||
# on the tag's attributes.
|
||
#
|
||
# * Fix up URLs in attributes by applying +Camping::Helpers#/+ to them.
|
||
# * Change action methods besides the supported methods (see {SUPPORTED})
|
||
# to +:post+ and add a hidden +_method+ input that still contains
|
||
# the original method.
|
||
# * Replace underscores in the class attribute by dashes (needed for
|
||
# Bootstrap).
|
||
#
|
||
# @param [Mab::Mixin::Tag] tag the tag that is completed
|
||
# @return [Mab::Mixin::Tag] the post-processed tag
|
||
def mab_done(tag)
|
||
attrs = tag._attributes
|
||
|
||
# Fix up URLs (normally done by Camping::Mab::mab_done)
|
||
[:href, :action, :src].map { |a| attrs[a] &&= self/attrs[a] }
|
||
|
||
# Transform underscores into dashes in all attributes
|
||
attrs.select { |attr_sym, _| attr_sym.to_s =~ /_/ } \
|
||
.each do |attr_sym, _|
|
||
new_attr_sym = attr_sym.to_s.gsub('_', '-').to_sym
|
||
attrs[new_attr_sym] = attrs.delete(attr_sym)
|
||
end
|
||
# Transform underscores into dashs in class names
|
||
if attrs.has_key?(:class) and attrs[:class].present?
|
||
attrs[:class] = attrs[:class].gsub('_', '-')
|
||
end
|
||
|
||
# The followin method processing is only for form tags.
|
||
return super unless tag._name == :form
|
||
|
||
meth = attrs[:method]
|
||
attrs[:method] = 'post' if override = !SUPPORTED.include?(meth)
|
||
# Inject a hidden input element with the proper method to the tag block
|
||
# if the form method is unsupported.
|
||
tag._block do |orig_blk|
|
||
input type: "hidden", name: "_method", value: meth
|
||
orig_blk.call
|
||
end if override
|
||
|
||
return super
|
||
end
|
||
|
||
include Mab::Indentation
|
||
|
||
end # module StopTime::Mab
|
||
|
||
# = The Stop… Camping Time! models
|
||
module StopTime::Models
|
||
|
||
# == The configuration class
|
||
#
|
||
# This class contains the application configuration constructed by
|
||
# default options (see {DefaultConfig}) merged with the configuration
|
||
# found in the configuration file (see {ConfigFile}).
|
||
class Config
|
||
|
||
# There should only be a single configuration object (for reloading).
|
||
include Singleton
|
||
|
||
# The default configuation file. (FIXME: shouldn't be hardcoded!)
|
||
ConfigFile = File.dirname(__FILE__) + "/config.yaml"
|
||
|
||
# The default configuration. Note that the configuration of the root
|
||
# will be merged with this configuration.
|
||
DefaultConfig = { "invoice_id" => "%Y%N",
|
||
"invoice_template" => "invoice",
|
||
"hourly_rate" => 20.0,
|
||
"time_resolution" => 1,
|
||
"date_new_entry" => "today",
|
||
"vat_rate" => 21.0 }
|
||
|
||
# Creates a new configuration object and loads the configuation.
|
||
# by reading the file +config.yaml+ on disk (see {ConfigFile}, parsing
|
||
# it, and performing a merge with the default config (see
|
||
# {DefaultConfig}).
|
||
def initialize
|
||
@config = DefaultConfig.dup
|
||
cfg = nil
|
||
# Read and parse the configuration.
|
||
begin
|
||
File.open(ConfigFile, "r") { |file| cfg = YAML.load(file) }
|
||
rescue => e
|
||
$stderr.puts "E: couldn't read configuration file: #{e}"
|
||
end
|
||
# Merge the loaded config with the default config (if it's a Hash)
|
||
case cfg
|
||
when Hash
|
||
@config.merge! cfg if cfg
|
||
when nil, false
|
||
# It's ok, it is empty.
|
||
else
|
||
$stderr.puts "W: wrong format detected in configuration file!"
|
||
end
|
||
end
|
||
|
||
# Reloads the configuration file.
|
||
def reload
|
||
load
|
||
end
|
||
|
||
# Returns the value for the given configuration option.
|
||
#
|
||
# @param [String] option a configuration option
|
||
# @return [Object] the value for the given configuration option
|
||
def [](option)
|
||
@config[option]
|
||
end
|
||
|
||
end # class StopTime::Models::Config
|
||
|
||
# == The customer class
|
||
#
|
||
# This class represents a customer that has projects/tasks
|
||
# for which invoices need to be generated.
|
||
class Customer < Base
|
||
# @!attribute id [r]
|
||
# @return [Fixnum] unique identification number
|
||
# @!attribute name
|
||
# @return [String] official (long) name
|
||
# @!attribute short_name
|
||
# @return [String] abbreviated name
|
||
# @!attribute financial_contact
|
||
# @return [String] name of the financial contact person/department
|
||
# @!attribute address_street
|
||
# @return [String] street part of the address
|
||
# @!attribute address_postal_code
|
||
# @return [String] zip/postal code part of the address
|
||
# @!attribute address_city
|
||
# @return [String] city part of the postal code
|
||
# @!attribute email
|
||
# @return [String] email address
|
||
# @!attribute phone
|
||
# @return [String] phone number
|
||
# @!attribute hourly_rate
|
||
# @return [Float] default hourly rate
|
||
# @!attribute time_specification
|
||
# @return [Boolean] flag whether the customer requires time
|
||
# specifications
|
||
# @!attribute created_at
|
||
# @return [Time] time of creation
|
||
# @!attribute updated_at
|
||
# @return [Time] time of last update
|
||
|
||
# @!attribute invoices
|
||
# @return [Array<Invoice>] associated invoices
|
||
has_many :tasks
|
||
# @!attribute tasks
|
||
# @return [Array<Task>] associated tasks
|
||
has_many :invoices
|
||
# @!attribute time_entries
|
||
# @return [Array<TimeEntry>] associated time entries
|
||
has_many :time_entries, through: :tasks
|
||
|
||
# Returns the short name if set, otherwise the full name.
|
||
#
|
||
# @return [String] the shortest name
|
||
def shortest_name
|
||
short_name.present? ? short_name : name
|
||
end
|
||
|
||
# Returns a list of tasks that have not been billed via in invoice.
|
||
#
|
||
# @return [Array<Task>] associated unbilled tasks
|
||
def unbilled_tasks
|
||
tasks.where("invoice_id IS NULL").order("name ASC")
|
||
end
|
||
|
||
# Returns a list of tasks that are active, i.e. that have not been
|
||
# billed and are either fixed cost or have some registered time.
|
||
#
|
||
# @return [Array<Task>] associated active tasks
|
||
def active_tasks
|
||
unbilled_tasks.select do |task|
|
||
task.fixed_cost? or task.time_entries.present?
|
||
end
|
||
end
|
||
end # class StopTime::Models::Customer
|
||
|
||
# == The task class
|
||
#
|
||
# This class represents a task (or project) of a customer on which time can
|
||
# be registered.
|
||
# There are two types of classes: with an hourly and with a fixed cost.
|
||
class Task < Base
|
||
# @!attribute id [r]
|
||
# @return [Fixnum] unique identification number
|
||
# @!attribute name
|
||
# @return [String] description
|
||
# @!attribute fixed_cost
|
||
# @return [Float] fixed cost of the task
|
||
# @!attribute hourly_rate
|
||
# @return [Float] hourly rate for the task
|
||
# @!attribute vat_rate
|
||
# @return [Float] VAT rate at time of billing
|
||
# @!attribute invoice_comment
|
||
# @return [String] extra comment for the invoice
|
||
# @!attribute created_at
|
||
# @return [Time] time of creation
|
||
# @!attribute updated_at
|
||
# @return [Time] time of last update
|
||
|
||
# @!attribute customer
|
||
# @return [Customer] associated customer
|
||
belongs_to :customer
|
||
# @!attribute time_entries
|
||
# @return [Array<TimeEntry>] associated registered time entries
|
||
has_many :time_entries
|
||
# @!attribute invoice
|
||
# @return [Invoice, nil] associated invoice if the task is billed,
|
||
# +nil+ otherwise
|
||
belongs_to :invoice
|
||
|
||
# Determines whether the task has a fixed cost.
|
||
# When +false+ is returned, one can assume the task has an hourly rate.
|
||
#
|
||
# @return [Boolean] whether the task has a fixed cost
|
||
def fixed_cost?
|
||
not self.fixed_cost.blank?
|
||
end
|
||
|
||
# Returns the type of the task
|
||
#
|
||
# @return ["fixed_cose", "hourly_rate"] the type of the task
|
||
def type
|
||
fixed_cost? ? "fixed_cost" : "hourly_rate"
|
||
end
|
||
|
||
# Returns a list of time entries that should be (and are not yet)
|
||
# billed.
|
||
#
|
||
# @return [Array<TimeEntry>] associated billable time entries
|
||
def billable_time_entries
|
||
time_entries.where("bill = 't'").order("start ASC")
|
||
end
|
||
|
||
# Returns the bill period of the task by means of an Array containing
|
||
# the first and last Time object found for registered time on this
|
||
# task.
|
||
# If no time is registered, the last time the task has been updated
|
||
# is returned.
|
||
#
|
||
# @return [Array(Time, Time)] the bill period of the task
|
||
def bill_period
|
||
bte = billable_time_entries
|
||
if bte.empty?
|
||
# FIXME: better defaults?
|
||
[updated_at, updated_at]
|
||
else
|
||
[bte.first.start, bte.last.end]
|
||
end
|
||
end
|
||
|
||
# Returns whether the task is billed, i.e. included in an invoice.
|
||
#
|
||
# @return [Boolean] whether the task is billed
|
||
def billed?
|
||
not invoice.nil?
|
||
end
|
||
|
||
# Returns a time and cost summary of the registered time on the task
|
||
# by means of Array of four values.
|
||
# In case of a fixed cost task, the first value is the total of time
|
||
# (in hours), the third value is the fixed cost, and the fourth value
|
||
# is the VAT.
|
||
# In case of a task with an hourly rate, the first value is
|
||
# the total of time (in hours), the second value is the hourly rate,
|
||
# the third value is the total amount (time times rate), and the fourth
|
||
# value is the VAT.
|
||
#
|
||
# @return [Array(Float, Float, Float, Float)] the summary of the task
|
||
def summary
|
||
case type
|
||
when "fixed_cost"
|
||
total = time_entries.inject(0.0) { |summ, te| summ + te.hours_total }
|
||
[total, nil, fixed_cost, fixed_cost * (vat_rate/100.0)]
|
||
when "hourly_rate"
|
||
time_entries.inject([0.0, hourly_rate, 0.0, 0.0]) do |summ, te|
|
||
total_cost = te.hours_total * hourly_rate
|
||
summ[0] += te.hours_total
|
||
summ[2] += total_cost
|
||
summ[3] += total_cost * (vat_rate/100.0)
|
||
summ
|
||
end
|
||
end
|
||
end
|
||
|
||
# Returns an invoice comment if the task is billed and if it is
|
||
# set, otherwise the name.
|
||
#
|
||
# @return [String] the invoice comment or task name (if not billed)
|
||
def comment_or_name
|
||
if billed? and self.invoice_comment.present?
|
||
self.invoice_comment
|
||
else
|
||
self.name
|
||
end
|
||
end
|
||
end # class StopTime::Models::Task
|
||
|
||
# == The time entry class
|
||
#
|
||
# This class represents an amount of time that is registered on a certain
|
||
# task.
|
||
class TimeEntry < Base
|
||
# @!attribute id [r]
|
||
# @return [Fixnum] unique identification number
|
||
# @!attribute date
|
||
# @return [Time] date of the entry
|
||
# @!attribute start
|
||
# @return [Time] start time of the entry
|
||
# @!attribute end
|
||
# @return [Time] finish time of the entry
|
||
# @!attribute bill
|
||
# @return [Boolean] flag whether to bill or not
|
||
# @!attribute comment
|
||
# @return [String] additional comment
|
||
# @!attribute created_at
|
||
# @return [Time] time of creation
|
||
# @!attribute updated_at
|
||
# @return [Time] time of last update
|
||
|
||
# @!attribute task
|
||
# @return [Task] associated task the time is registered for
|
||
belongs_to :task
|
||
# @!attribute customer
|
||
# @return [Customer] associated customer
|
||
has_one :customer, through: :task
|
||
|
||
before_validation :round_start_end
|
||
|
||
# Returns the total amount of time, the duration, in hours (up to
|
||
# 2 decimals only!).
|
||
#
|
||
# @return [Float] the total amount of registered time
|
||
def hours_total
|
||
((self.end - self.start) / 1.hour).round(2)
|
||
end
|
||
|
||
def in_current_month?
|
||
self.end.month == Time.now.month
|
||
end
|
||
|
||
#########
|
||
protected
|
||
|
||
# Rounds the start and end time to the configured resolution using
|
||
# {#round_time).
|
||
#
|
||
# @return [void]
|
||
def round_start_end
|
||
self.start = round_time(self.start)
|
||
self.end = round_time(self.end)
|
||
end
|
||
|
||
#######
|
||
private
|
||
|
||
# Rounds the time using the configured time resolution.
|
||
#
|
||
# @param [Time] t the input time
|
||
# @return [Time] the rounded time
|
||
def round_time(t)
|
||
config = Config.instance
|
||
res = config["time_resolution"]
|
||
down = t - (t.to_i % res.minutes)
|
||
up = down + res.minutes
|
||
|
||
diff_down = t - down
|
||
diff_up = up - t
|
||
|
||
diff_down < diff_up ? down : up
|
||
end
|
||
end # class StopTime::Models::TimeEntry
|
||
|
||
# == The invoice class
|
||
#
|
||
# This class represents an invoice for a customer that contains billed
|
||
# tasks and through the tasks registered time.
|
||
class Invoice < Base
|
||
# @!attribute id [r]
|
||
# @return [Fixnum] unique identification number
|
||
# @!attribute number
|
||
# @return [Fixnum] invoice number
|
||
# @!attribute paid
|
||
# @return [Boolean] flag whether the invoice has been paid
|
||
# @!attribute include_specification
|
||
# @return [Boolean] flag whether the invoice should include a time
|
||
# specification
|
||
# @!attribute created_at
|
||
# @return [Time] time of creation
|
||
# @!attribute updated_at
|
||
# @return [Time] time of last update
|
||
|
||
# @!attribute company_info
|
||
# @return [CompanyInfo] associated company info
|
||
belongs_to :company_info
|
||
# @!attribute customer
|
||
# @return [Customer] associated customer
|
||
belongs_to :customer
|
||
# @!attribute tasks
|
||
# @return [Array<Task>] associated billed tasks
|
||
has_many :tasks
|
||
# @!attribute time_entries
|
||
# @return [Array<TimeEntry>] associated billed time entries
|
||
has_many :time_entries, through: :tasks
|
||
|
||
default_scope lambda { order('number DESC') }
|
||
|
||
# Returns a time and cost summary for each of the associated tasks.
|
||
# See also {Task#summary} for the specification of the array.
|
||
#
|
||
# @return [Hash{Task=>Array(Float, Float, Float, Float)}] mapping from
|
||
# task to summary
|
||
def summary
|
||
summ = {}
|
||
tasks.each { |task| summ[task] = task.summary }
|
||
return summ
|
||
end
|
||
|
||
# Returns a total per VAT rate for the summary of the associated tasks.
|
||
# See also {#summary}.
|
||
#
|
||
# @return [Hash{Float=>Float}] mapping from VAT rate to total for that
|
||
# rate with respect to the summary
|
||
def vat_summary
|
||
vatsumm = Hash.new(0.0)
|
||
summary.each do |task, summ|
|
||
vatsumm[task.vat_rate] += summ[3]
|
||
end
|
||
return vatsumm
|
||
end
|
||
|
||
# Returns the invoice period based on the associated tasks. This
|
||
# period is a tuple of the earliest of the starting times and the
|
||
# latest of the ending times of all associated tasks.
|
||
# If there are no tasks, the creation time is used.
|
||
#
|
||
# See also {Task#bill_period}.
|
||
#
|
||
# @return [Array(Time, Time)] the invoice period
|
||
def period
|
||
return [created_at, created_at] if tasks.empty?
|
||
|
||
p = [DateTime.now, DateTime.new(0)]
|
||
tasks.each do |task|
|
||
tp = task.bill_period
|
||
p[0] = tp[0] if tp[0] < p[0]
|
||
p[1] = tp[1] if tp[1] > p[1]
|
||
end
|
||
return p
|
||
end
|
||
|
||
# Returns the total amount (including VAT).
|
||
#
|
||
# @note VAT will only be applied if the VAT number is given in the
|
||
# associated company information!
|
||
#
|
||
# @return [Float] the total amount (including VAT)
|
||
def total_amount
|
||
subtotal, vattotal = summary.inject([0.0, 0.0]) do |tot, (task, summ)|
|
||
tot[0] += summ[2]
|
||
tot[1] += summ[3]
|
||
tot
|
||
end
|
||
|
||
if company_info.vatno.blank?
|
||
subtotal
|
||
else
|
||
subtotal + vattotal
|
||
end
|
||
end
|
||
|
||
# Returns if the invoice is past due (i.e. it has not been paid within
|
||
# the required amount of days).
|
||
#
|
||
# @return [Boolean] whether payment of the invoice is past due
|
||
def past_due?
|
||
not paid? and (Time.now - created_at) > 30.days # FIXME: hardcoded!
|
||
end
|
||
|
||
# Returns if the invoice is _way_ past due (i.e. it has not been paid
|
||
# within twice the required amount of days).
|
||
#
|
||
# @return [Boolean] whether payment of the invoice is way past due
|
||
def way_past_due?
|
||
past_due? and (Time.now - created_at) > 2 * 30.days
|
||
end
|
||
end # class StopTime::Models::Invoice
|
||
|
||
# == The company information class
|
||
#
|
||
# This class contains information about the company or sole
|
||
# proprietorship of the user of Stop… Camping Time!
|
||
class CompanyInfo < Base
|
||
# @!attribute id [r]
|
||
# @return [Fixnum] unique identification number
|
||
# @!attribute name
|
||
# @return [String] official company name
|
||
# @!attribute contact_name
|
||
# @return [String] optional personal contact name
|
||
# @!attribute address_street
|
||
# @return [String] street part of the address
|
||
# @!attribute address_postal_code
|
||
# @return [String] zip/postal code part of the address
|
||
# @!attribute address_city
|
||
# @return [String] city part of the postal code
|
||
# @!attribute country
|
||
# @return [String] country of residence
|
||
# @!attribute country_code
|
||
# @return [String] two letter country code
|
||
# @!attribute email
|
||
# @return [String] email address
|
||
# @!attribute phone
|
||
# @return [String] phone number
|
||
# @!attribute cell
|
||
# @return [String] cellular phone number
|
||
# @!attribute website
|
||
# @return [String] web address
|
||
# @!attribute chamber
|
||
# @return [String] optional chamber of commerce ID number
|
||
# @!attribute vatno
|
||
# @return [String] optional VAT number
|
||
# @!attribute bank_name
|
||
# @return [String] name of the bank
|
||
# @!attribute bank_bic
|
||
# @return [String] bank identification code (or: SWIFT code)
|
||
# @!attribute accountname
|
||
# @return [String] name of the bank account holder
|
||
# @!attribute accountno
|
||
# @return [String] number of the bank account
|
||
# @!attribute accountiban
|
||
# @return [String] international bank account number
|
||
# @!attribute created_at
|
||
# @return [Time] time of creation
|
||
# @!attribute updated_at
|
||
# @return [Time] time of last update
|
||
|
||
# @!attribute invoices
|
||
# @return [Array<Invoice>] associated invoices
|
||
has_many :invoices
|
||
# @!attribute original
|
||
# @return [CompanyInfo] original (previous) revision
|
||
belongs_to :original, class_name: "CompanyInfo"
|
||
|
||
# Returns the revision number.
|
||
# @return [Fixnum] the revision number
|
||
def revision
|
||
id
|
||
end
|
||
end # class StopTime::Models::CompanyInfo
|
||
|
||
# @private
|
||
class StopTimeTables < V 1.0
|
||
def self.up
|
||
create_table Customer.table_name do |t|
|
||
t.string :name, :short_name,
|
||
:address_street, :address_postal_code, :address_city,
|
||
:email, :phone
|
||
t.timestamps
|
||
end
|
||
create_table Task.table_name do |t|
|
||
t.integer :customer_id
|
||
t.string :name
|
||
t.timestamps
|
||
end
|
||
create_table TimeEntry.table_name do |t|
|
||
t.integer :task_id, :invoice_id
|
||
t.datetime :start, :end
|
||
t.timestamps
|
||
end
|
||
end
|
||
|
||
def self.down
|
||
drop_table Customer.table_name
|
||
drop_table Task.table_name
|
||
drop_table TimeEntry.table_name
|
||
end
|
||
end
|
||
|
||
# @private
|
||
class CommentSupport < V 1.1
|
||
def self.up
|
||
add_column(TimeEntry.table_name, :comment, :string)
|
||
end
|
||
|
||
def self.down
|
||
remove_column(TimeEntry.table_name, :comment)
|
||
end
|
||
end
|
||
|
||
# @private
|
||
class BilledFlagSupport < V 1.2
|
||
def self.up
|
||
add_column(TimeEntry.table_name, :bill, :boolean)
|
||
end
|
||
|
||
def self.down
|
||
remove_column(TimeEntry.table_name, :bill)
|
||
end
|
||
end
|
||
|
||
# @private
|
||
class HourlyRateSupport < V 1.3
|
||
def self.up
|
||
config = Config.instance
|
||
add_column(Customer.table_name, :hourly_rate, :float,
|
||
null: false,
|
||
default: config["hourly_rate"])
|
||
end
|
||
|
||
def self.down
|
||
remove_column(Customer.table_name, :hourly_rate)
|
||
end
|
||
end
|
||
|
||
# @private
|
||
class FixedCostTaskSupport < V 1.4
|
||
def self.up
|
||
add_column(Task.table_name, :billed, :boolean)
|
||
add_column(Task.table_name, :fixed_cost, :float)
|
||
add_column(Task.table_name, :hourly_rate, :float)
|
||
end
|
||
|
||
def self.down
|
||
remove_column(Task.table_name, :billed)
|
||
remove_column(Task.table_name, :fixed_cost)
|
||
remove_column(Task.table_name, :hourly_rate, :float)
|
||
end
|
||
end
|
||
|
||
# @private
|
||
class InvoiceSupport < V 1.5
|
||
def self.up
|
||
create_table Invoice.table_name do |t|
|
||
t.integer :number, :customer_id
|
||
t.boolean :payed
|
||
t.timestamps
|
||
end
|
||
end
|
||
|
||
def self.down
|
||
drop_table Invoice.table_name
|
||
end
|
||
end
|
||
|
||
# @private
|
||
class CompanyInfoSupport < V 1.6
|
||
def self.up
|
||
create_table CompanyInfo.table_name do |t|
|
||
t.string :name, :contact_name,
|
||
:address_street, :address_postal_code, :address_city,
|
||
:country, :country_code,
|
||
:phone, :cell, :email, :website,
|
||
:chamber, :vatno, :accountname, :accountno
|
||
t.timestamps
|
||
end
|
||
|
||
# Add company info record with defaults.
|
||
cinfo = CompanyInfo.create(name: "My Company",
|
||
contact_name: "Me",
|
||
country: "The Netherlands",
|
||
country_code: "NL")
|
||
cinfo.save
|
||
end
|
||
|
||
def self.down
|
||
drop_table CompanyInfo.table_name
|
||
end
|
||
end
|
||
|
||
# @private
|
||
class ImprovedInvoiceSupport < V 1.7
|
||
def self.up
|
||
add_column(Task.table_name, :invoice_id, :integer)
|
||
remove_column(Task.table_name, :billed)
|
||
remove_column(TimeEntry.table_name, :invoice_id)
|
||
end
|
||
|
||
def self.down
|
||
remove_column(Task.table_name, :invoice_id, :integer)
|
||
add_column(Task.table_name, :billed, :boolean)
|
||
add_column(TimeEntry.table_name, :invoice_id)
|
||
end
|
||
end
|
||
|
||
# @private
|
||
class TimeEntryDateSupport < V 1.8
|
||
def self.up
|
||
add_column(TimeEntry.table_name, :date, :datetime)
|
||
TimeEntry.all.each do |te|
|
||
te.date = te.start.at_beginning_of_day
|
||
te.save
|
||
end
|
||
end
|
||
|
||
def self.down
|
||
remove_column(TimeEntry.table_name, :date)
|
||
end
|
||
end
|
||
|
||
# @private
|
||
class PaidFlagTypoFix < V 1.9
|
||
def self.up
|
||
rename_column(Invoice.table_name, :payed, :paid)
|
||
end
|
||
|
||
def self.down
|
||
rename_column(Invoice.table_name, :paid, :payed)
|
||
end
|
||
end
|
||
|
||
# @private
|
||
class InvoiceCommentsSupport < V 1.91
|
||
def self.up
|
||
add_column(Task.table_name, :invoice_comment, :string)
|
||
end
|
||
|
||
def self.down
|
||
remove_column(Task.table_name, :invoice_comment)
|
||
end
|
||
end
|
||
|
||
# @private
|
||
class FinancialInfoSupport < V 1.92
|
||
def self.up
|
||
add_column(CompanyInfo.table_name, :bank_name, :string)
|
||
add_column(CompanyInfo.table_name, :bank_bic, :string)
|
||
add_column(CompanyInfo.table_name, :accountiban, :string)
|
||
add_column(Customer.table_name, :financial_contact, :string)
|
||
end
|
||
|
||
def self.down
|
||
remove_column(CompanyInfo.table_name, :bank_name)
|
||
remove_column(CompanyInfo.table_name, :bank_bic)
|
||
remove_column(CompanyInfo.table_name, :accountiban)
|
||
remove_column(Customer.table_name, :financial_contact)
|
||
end
|
||
end
|
||
|
||
# @private
|
||
class CompanyInfoRevisioning < V 1.93
|
||
def self.up
|
||
add_column(CompanyInfo.table_name, :original_id, :integer)
|
||
add_column(Invoice.table_name, :company_info_id, :integer)
|
||
ci = CompanyInfo.last
|
||
Invoice.all.each do |i|
|
||
i.company_info = ci
|
||
i.save
|
||
end
|
||
end
|
||
|
||
def self.down
|
||
remove_column(CompanyInfo.table_name, :original_id)
|
||
remove_column(Invoice.table_name, :company_info_id)
|
||
end
|
||
end
|
||
|
||
# @private
|
||
class VATRatePerTaskSupport < V 1.94
|
||
def self.up
|
||
add_column(Task.table_name, :vat_rate, :float)
|
||
config = Config.instance
|
||
Task.all.each do |t|
|
||
t.vat_rate = config['vat_rate']
|
||
t.save
|
||
end
|
||
end
|
||
|
||
def self.down
|
||
remove_column(Task.table_name, :vat_rate)
|
||
end
|
||
end
|
||
|
||
# @private
|
||
class TimeSpecificationSupport < V 1.95
|
||
def self.up
|
||
add_column(Customer.table_name, :time_specification, :boolean)
|
||
add_column(Invoice.table_name, :include_specification, :boolean)
|
||
|
||
Customer.reset_column_information
|
||
Invoice.reset_column_information
|
||
end
|
||
|
||
def self.down
|
||
remove_column(Customer.table_name, :time_specification)
|
||
remove_column(Invoice.table_name, :include_specification)
|
||
end
|
||
end
|
||
|
||
end # StopTime::Models
|
||
|
||
# = The Stop… Camping Time! helpers
|
||
module StopTime::Helpers
|
||
|
||
# Returns the date/time to use for new time entry defaults, or +nil+ if
|
||
# none is to be used. This method can use the last time entry (if any
|
||
# and if so configured). The result is based on the +date_new_entry+
|
||
# configuration option.
|
||
#
|
||
# @param last_entry [DateTime] the last time entry to use if configured
|
||
# for "previous"
|
||
# @return [DateTime, nil] the date/time to be used for new entry defaults
|
||
def date_time_new_entry(last_entry = nil)
|
||
case @config["date_new_entry"]
|
||
when "previous"
|
||
TimeEntry.last.end
|
||
when "today"
|
||
DateTime.now
|
||
when "none"
|
||
nil
|
||
end
|
||
end
|
||
|
||
end
|
||
|
||
# = The Stop… Camping Time! controllers
|
||
module StopTime::Controllers
|
||
|
||
# == The index controller
|
||
#
|
||
# Controller that presents the overview as the index, listing
|
||
# the running tasks and projects per customer.
|
||
#
|
||
# path:: +/+
|
||
# view:: {Views#overview}
|
||
class Index
|
||
# Shows an overview of all unbilled projects/tasks per customer using
|
||
# {Views#overview}.
|
||
def get
|
||
@tasks = {}
|
||
@task_count = 0
|
||
@active_tasks = {}
|
||
@active_task_count = 0
|
||
@active_tasks_summary = {}
|
||
@totals = [0.0, 0,0]
|
||
Customer.all.each do |customer|
|
||
tasks = customer.unbilled_tasks
|
||
@tasks[customer] = tasks
|
||
@task_count += tasks.count
|
||
active_tasks = customer.active_tasks
|
||
@active_tasks[customer] = active_tasks
|
||
@active_task_count += active_tasks.count
|
||
@active_tasks_summary[customer] =
|
||
active_tasks.inject([0.0, 0.0]) do |summ, task|
|
||
task_summ = task.summary
|
||
summ[0] += task_summ[0]
|
||
@totals[0] += task_summ[0]
|
||
summ[1] += task_summ[2]
|
||
@totals[1] += task_summ[2]
|
||
summ
|
||
end
|
||
end
|
||
render :overview
|
||
end
|
||
end # class StopTime::Controllers::Index
|
||
|
||
# == The customers controller
|
||
#
|
||
# Controller for viewing a list of existing customers or creating a new
|
||
# one.
|
||
#
|
||
# path:: +/customers+
|
||
# view:: {Views#customers} and {Views#customer_form}
|
||
class Customers
|
||
# Show the list of customers and displays them using {Views#customers}.
|
||
def get
|
||
@customers = Customer.order("name ASC")
|
||
render :customers
|
||
end
|
||
|
||
# Creates a new customer object ({Models::Customer}) if the input is
|
||
# valid and redirects to {CustomersN}.
|
||
# If the provided information is invalid, the errors are retrieved
|
||
# and shown in the initial form ({Views#customer_form}).
|
||
def post
|
||
return redirect R(Customers) if @input.cancel
|
||
@customer = Customer.create(
|
||
name: @input.name,
|
||
short_name: @input.short_name,
|
||
financial_contact: @input.financial_contact,
|
||
address_street: @input.address_street,
|
||
address_postal_code: @input.address_postal_code,
|
||
address_city: @input.address_city,
|
||
email: @input.email,
|
||
phone: @input.phone,
|
||
hourly_rate: @input.hourly_rate)
|
||
@customer.save
|
||
if @customer.invalid?
|
||
@errors = @customer.errors
|
||
@target = [Customer]
|
||
@button = "create"
|
||
return render :customer_form
|
||
end
|
||
redirect R(CustomersN, @customer.id)
|
||
end
|
||
end # class StopTime::Controllers::CustomersN
|
||
|
||
# == The customer creation controller
|
||
#
|
||
# Controller for filling in the information to create a new customer.
|
||
#
|
||
# path:: +/customers/new+
|
||
# view:: {Views#customer_form}
|
||
class CustomersNew
|
||
# Generates the form to create a new customer object ({Models::Customer})
|
||
# using {Views#customer_form}.
|
||
def get
|
||
@customer = Customer.new(hourly_rate: @config['hourly_rate'])
|
||
@input = @customer.attributes
|
||
@tasks = []
|
||
|
||
@target = [Customers]
|
||
@button = "create"
|
||
render :customer_form
|
||
end
|
||
end
|
||
|
||
# == The customer controller
|
||
#
|
||
# Controller for viewing and updating information of a customer.
|
||
#
|
||
# path:: +/customers/+_customer_id_
|
||
# view:: {Views#customer_form}
|
||
class CustomersN
|
||
# Finds the specific customer for the given customer ID and shows
|
||
# a form for updating using {Views#customer_form}.
|
||
#
|
||
# @param [Fixnum] customer_id ID of the customer
|
||
def get(customer_id)
|
||
@customer = Customer.find(customer_id)
|
||
@input = @customer.attributes
|
||
@tasks = @customer.tasks.order("name ASC, invoice_id ASC")
|
||
# FIXME: this dirty hack assumes that tasks have unique names,
|
||
# becasue there is no reference from billed tasks to its original
|
||
# task.
|
||
@billed_tasks = {}
|
||
cur_active_task = nil
|
||
@tasks.each do |task|
|
||
if task.billed?
|
||
if cur_active_task.nil? or
|
||
task.name != cur_active_task.name
|
||
# Apparently, this is billed but it does not belong to the
|
||
# current active task, so probably it was a fixed-cost task
|
||
cur_active_task = task
|
||
@billed_tasks[task] = [task]
|
||
else
|
||
@billed_tasks[cur_active_task] << task
|
||
end
|
||
else
|
||
cur_active_task = task
|
||
@billed_tasks[task] = []
|
||
end
|
||
end
|
||
|
||
@time_entries = @customer.time_entries.order("start DESC")\
|
||
.reject { |te| te.task.billed? }
|
||
@invoices = @customer.invoices
|
||
@invoices.each do |i|
|
||
@input["paid_#{i.number}"] = true if i.paid?
|
||
end
|
||
@task_list = Hash.new { |h, k| h[k] = Array.new }
|
||
@customer.tasks.reject { |t| t.billed? }.each do |t|
|
||
@task_list[t.customer.shortest_name] << [t.id, t.name]
|
||
end
|
||
@input["bill"] = true # Bill by default.
|
||
@input["task"] = @time_entries.first.task.id if @time_entries.present?
|
||
|
||
@target = [CustomersN, @customer.id]
|
||
@button = "update"
|
||
@edit_task = true
|
||
render :customer_form
|
||
end
|
||
|
||
# Updates or deletes the customer with the given customer ID if the
|
||
# input is valid and redirects to {CustomersN}.
|
||
# If the provided information is invalid, the errors are retrieved
|
||
# and shown in the initial form ({Views#customer_form}).
|
||
#
|
||
# @param [Fixnum] customer_id ID of the customer
|
||
def post(customer_id)
|
||
return redirect R(Customers) if @input.cancel
|
||
@customer = Customer.find(customer_id)
|
||
if @input.has_key? "delete"
|
||
@customer.delete
|
||
elsif @input.has_key? "update"
|
||
attrs = ["name", "short_name", "financial_contact",
|
||
"address_street", "address_postal_code", "address_city",
|
||
"email", "phone", "hourly_rate"]
|
||
attrs.each do |attr|
|
||
@customer[attr] = @input[attr]
|
||
end
|
||
@customer.time_specification = @input.has_key? "time_specification"
|
||
@customer.save
|
||
if @customer.invalid?
|
||
@errors = @customer.errors
|
||
@button = "update"
|
||
return render :customer_form
|
||
end
|
||
end
|
||
redirect R(CustomersN, customer_id)
|
||
end
|
||
end # class StopTime::Controllers::CustomersN
|
||
|
||
# == The tasks controller for a specific customer
|
||
#
|
||
# Controller for creating, editing and deleting a task for a
|
||
# specific customer.
|
||
#
|
||
# path:: +/customers/+_customer_id_+/tasks+
|
||
# view:: {Views#task_form}
|
||
class CustomersNTasks
|
||
# Creates, updates or deletes a task object ({Models::Task}) for a
|
||
# customer with the given customer ID if the input is valid and
|
||
# redirects to {CustomersN}.
|
||
# If the provided information is invalid, the errors are retrieved and
|
||
# shown in the initial form ({Views#task_form}).
|
||
#
|
||
# @param [Fixnum] customer_id ID of the customer
|
||
def post(customer_id)
|
||
return redirect R(Customers) if @input.cancel
|
||
if @input.has_key? "delete"
|
||
@task = Task.find(@input.task_id)
|
||
@task.delete
|
||
elsif @input.has_key? "edit"
|
||
return redirect R(CustomersNTasksN, customer_id, @input.task_id)
|
||
else
|
||
@task = Task.create(
|
||
customer_id: customer_id,
|
||
name: @input.name)
|
||
case @input.type
|
||
when "fixed_cost"
|
||
@task.fixed_cost = @input.fixed_cost
|
||
@task.hourly_rate = nil
|
||
when "hourly_rate"
|
||
@task.fixed_cost = nil
|
||
@task.hourly_rate = @input.hourly_rate
|
||
# FIXME: catch invalid task types!
|
||
end
|
||
@task.vat_rate = @input.vat_rate
|
||
@task.save
|
||
if @task.invalid?
|
||
@errors = @task.errors
|
||
@customer = Customer.find(customer_id)
|
||
@customer_list = Customer.all.map { |c| [c.id, c.shortest_name] }
|
||
@time_entries = @task.time_entries.order("start DESC")
|
||
@time_entries.each do |te|
|
||
@input["bill_#{te.id}"] = true if te.bill?
|
||
end
|
||
|
||
@target = [CustomersNTasks, customer_id]
|
||
@method = "create"
|
||
return render :task_form
|
||
end
|
||
end
|
||
redirect R(CustomersN, customer_id)
|
||
end
|
||
end # class StopTime::Controllers::CustomersNTasks
|
||
|
||
# == The task creation controller for a specific customer
|
||
#
|
||
# Controller for filling in the information to create a new task
|
||
# for a specific customer.
|
||
#
|
||
# path:: +/customers/+_customer_id_+/tasks/new+
|
||
# view:: {Views#task_form}
|
||
class CustomersNTasksNew
|
||
# Generates the form to create a new task object ({Models::Task})
|
||
# for a customer with the given customer ID_ using {Views#task_form}.
|
||
#
|
||
# @param [Fixnum] customer_id ID of the customer
|
||
def get(customer_id)
|
||
@customer = Customer.find(customer_id)
|
||
@customer_list = Customer.all.map { |c| [c.id, c.shortest_name] }
|
||
@task = Task.new(hourly_rate: @customer.hourly_rate,
|
||
vat_rate: @config["vat_rate"])
|
||
@input = @task.attributes
|
||
@input["type"] = @task.type # FIXME: find nicer way!
|
||
@input["customer"] = @customer.id
|
||
|
||
@target = [CustomersNTasks, customer_id]
|
||
@method = "create"
|
||
render :task_form
|
||
end
|
||
end # class StopTime::Controllers::CustomersNTasksNew
|
||
|
||
# == The task controller for a specific customer
|
||
#
|
||
# Controller for viewing and updating information of a task for
|
||
# a specific customer.
|
||
#
|
||
# path:: +/customers/+_customer_id_+/tasks/+_task_id_
|
||
# view:: {Views#task_form}
|
||
class CustomersNTasksN
|
||
# Finds the task with the given task ID for the customer with the given
|
||
# customer ID and shows a form for updating using {Views#task_form}.
|
||
#
|
||
# @param [Fixnum] customer_id ID of the customer
|
||
# @param [Fixnum] task_id ID of the task
|
||
def get(customer_id, task_id)
|
||
@customer = Customer.find(customer_id)
|
||
@customer_list = Customer.all.map { |c| [c.id, c.shortest_name] }
|
||
@task = Task.find(task_id)
|
||
@time_entries = @task.time_entries.order("start DESC")
|
||
|
||
@input = @task.attributes
|
||
@input["type"] = @task.type
|
||
@input["customer"] = @customer.id
|
||
@time_entries.each do |te|
|
||
@input["bill_#{te.id}"] = true if te.bill?
|
||
end
|
||
@input["bill"] = true # Bill new entries by default.
|
||
|
||
# FIXME: Check that task is of that customer.
|
||
@target = [CustomersNTasksN, customer_id, task_id]
|
||
@method = "update"
|
||
render :task_form
|
||
end
|
||
|
||
# Updates the task with the given task ID_ for the customer with
|
||
# the given customer ID if the input is valid and redirects to
|
||
# {CustomersN}.
|
||
# If the provided information is invalid, the errors are retrieved
|
||
# and shown in the intial form ({Views#task_form}).
|
||
#
|
||
# @param [Fixnum] customer_id ID of the customer
|
||
# @param [Fixnum] task_id ID of the task
|
||
def post(customer_id, task_id)
|
||
return redirect R(CustomersN, customer_id) if @input.cancel
|
||
@task = Task.find(task_id)
|
||
if @input.has_key? "update"
|
||
@task.customer = Customer.find(@input["customer"])
|
||
@task.name = @input["name"] unless @input["name"].blank?
|
||
if @task.billed? and @input["invoice_comment"].present?
|
||
@task.invoice_comment = @input["invoice_comment"]
|
||
end
|
||
case @input.type
|
||
when "fixed_cost"
|
||
@task.fixed_cost = @input.fixed_cost
|
||
@task.hourly_rate = nil
|
||
when "hourly_rate"
|
||
@task.fixed_cost = nil
|
||
@task.hourly_rate = @input.hourly_rate
|
||
end
|
||
@task.save
|
||
if @task.invalid?
|
||
@errors = @task.errors
|
||
@customer = Customer.find(customer_id)
|
||
@customer_list = Customer.all.map { |c| [c.id, c.shortest_name] }
|
||
@target = [CustomersNTasksN, customer_id, task_id]
|
||
@method = "update"
|
||
return render :task_form
|
||
end
|
||
end
|
||
redirect R(CustomersN, customer_id)
|
||
end
|
||
end # class StopTime::Controllers::CustomersNTasksN
|
||
|
||
# == The invoices controller for a specific customer
|
||
#
|
||
# Controller for creating and viewing invoices for a specific customer.
|
||
#
|
||
# path:: +/customers/+_customer_id_+/invoices+
|
||
# view:: {Views#invoices}
|
||
class CustomersNInvoices
|
||
# Creates a new invoice object ({Models::Invoice}) for the customer
|
||
# with the given customer ID if the input is valid and redirects to
|
||
# {CustomersNInvoicesX}.
|
||
#
|
||
# A unique number is generated for the invoice by taking the
|
||
# year and a sequence number.
|
||
#
|
||
# A fixed cost task is directly tied to the invoice.
|
||
#
|
||
# For a task with an hourly rate, a task copy is created with the
|
||
# selected time to bill and put in the invoice; the remaining unbilled
|
||
# time is left in the original task.
|
||
#
|
||
# @param [Fixnum] customer_id ID of the customer
|
||
def post(customer_id)
|
||
return redirect R(CustomersN, customer_id) if @input.cancel
|
||
|
||
# Create the invoice.
|
||
last = Invoice.reorder('number ASC').last
|
||
number = if last
|
||
last_year = last.number.to_s[0..3].to_i
|
||
if Time.now.year > last_year
|
||
number = ("%d%02d" % [Time.now.year, 1])
|
||
else
|
||
number = last.number.succ
|
||
end
|
||
else
|
||
number = ("%d%02d" % [Time.now.year, 1])
|
||
end
|
||
invoice = Invoice.create(number: number)
|
||
invoice.customer = Customer.find(customer_id)
|
||
invoice.company_info = CompanyInfo.last
|
||
invoice.include_specification = invoice.customer.time_specification
|
||
|
||
# Handle the hourly rated tasks first by looking at the selected time
|
||
# entries.
|
||
tasks = Hash.new { |h, k| h[k] = Array.new }
|
||
@input["time_entries"].each do |entry|
|
||
time_entry = TimeEntry.find(entry)
|
||
tasks[time_entry.task] << time_entry
|
||
end unless @input["time_entries"].blank?
|
||
tasks.each_key do |task|
|
||
# Create a new (billed) task clone that contains the selected time
|
||
# entries, leave the rest unbilled and associated with their task.
|
||
bill_task = task.dup
|
||
task.time_entries = task.time_entries - tasks[task]
|
||
task.save
|
||
bill_task.time_entries = tasks[task]
|
||
bill_task.invoice_comment = @input["task_#{task.id}_comment"]
|
||
bill_task.save
|
||
invoice.tasks << bill_task
|
||
end
|
||
|
||
# Then, handle the (selected) fixed cost tasks.
|
||
@input["tasks"].each do |task|
|
||
task = Task.find(task)
|
||
next unless task.fixed_cost?
|
||
task.invoice_comment = @input["task_#{task.id}_comment"]
|
||
task.save
|
||
invoice.tasks << task
|
||
end unless @input["tasks"].blank?
|
||
invoice.save
|
||
|
||
redirect R(CustomersNInvoicesX, customer_id, number)
|
||
end
|
||
end # class StopTime::Controllers::CustomersNInvoices
|
||
|
||
# == The invoice controller for a specific customer
|
||
#
|
||
# Controller for viewing and updating information of an invoice for a
|
||
# specific customer.
|
||
#
|
||
# path:: +/customers/+_customer_id_+/invoices/+_invoice_number_
|
||
# view:: {Views#invoice_form}
|
||
class CustomersNInvoicesX < R '/customers/(\d+)/invoices/([^/]+)'
|
||
include ActionView::Helpers::NumberHelper
|
||
include I18n
|
||
|
||
# Finds the invoice with the given invoice number for the customer
|
||
# with the given customer ID and shows a form for updating using
|
||
# {Views#invoice_form}.
|
||
# If the invoice_number has a .pdf or .tex suffix, a PDF or LaTeX
|
||
# source document is generated for the invoice (if not already
|
||
# existing) and served via a redirect to the {Static} controller.
|
||
#
|
||
# @param [Fixnum] customer_id ID of the customer
|
||
# @param [Fixnum] invoice_number number of the invoice
|
||
def get(customer_id, invoice_number)
|
||
# FIXME: make this (much) nicer!
|
||
if m = invoice_number.match(/(\d+)\.(\w+)$/)
|
||
@number = m[1].to_i
|
||
@format = m[2]
|
||
else
|
||
@number = invoice_number.to_i
|
||
@format = "html"
|
||
end
|
||
@invoice = Invoice.find_by_number(@number)
|
||
@customer = Customer.find(customer_id)
|
||
|
||
@company = @invoice.company_info
|
||
@tasks = @invoice.summary
|
||
@vat = @invoice.vat_summary
|
||
@period = @invoice.period
|
||
|
||
tex_file = PUBLIC_DIR + "invoices/#{@number}.tex"
|
||
pdf_file = PUBLIC_DIR + "invoices/#{@number}.pdf"
|
||
if @format == "html"
|
||
@input = @invoice.attributes
|
||
@invoice_file_present = tex_file.exist?
|
||
render :invoice_form
|
||
elsif @format == "tex"
|
||
_generate_invoice_tex(@number) unless tex_file.exist?
|
||
redirect R(Static, "") + "invoices/#{tex_file.basename}"
|
||
elsif @format == "pdf"
|
||
_generate_invoice_pdf(@number) unless pdf_file.exist?
|
||
redirect R(Static, "") + "invoices/#{pdf_file.basename}"
|
||
end
|
||
end
|
||
|
||
# Updates the invoice with the given invoice number for the customer
|
||
# with the given customer ID and redirects to {CustomersNInvoicesX}.
|
||
#
|
||
# @param [Fixnum] customer_id ID of the customer
|
||
# @param [Fixnum] invoice_number number of the invoice
|
||
def post(customer_id, invoice_number)
|
||
invoice = Invoice.find_by_number(invoice_number)
|
||
invoice.paid = @input.has_key? "paid"
|
||
invoice.include_specification = @input.has_key? "include_specification"
|
||
invoice.save
|
||
|
||
redirect R(CustomersNInvoicesX, customer_id, invoice_number)
|
||
end
|
||
|
||
# Find the invoice with the given invoice number for the customer
|
||
# with the given customer ID and deletes existing invoice files.
|
||
#
|
||
# @param [Fixnum] customer_id ID of the customer
|
||
# @param [Fixnum] invoice_number number of the invoice
|
||
def delete(customer_id, invoice_number)
|
||
@invoice = Invoice.find_by_number(@number)
|
||
@customer = Customer.find(customer_id)
|
||
|
||
tex_file = PUBLIC_DIR + "invoices/#{invoice_number}.tex"
|
||
File.unlink(tex_file) if tex_file.exist?
|
||
|
||
pdf_file = PUBLIC_DIR + "invoices/#{invoice_number}.pdf"
|
||
File.unlink(pdf_file) if pdf_file.exist?
|
||
|
||
redirect R(CustomersNInvoicesX, customer_id, invoice_number)
|
||
end
|
||
|
||
########################
|
||
# Private helper methods
|
||
#
|
||
private
|
||
|
||
# Escapes the given string such that it can be used as in in
|
||
# LaTeX.
|
||
#
|
||
# @param [String] string the given string
|
||
def _escape_latex(string)
|
||
escape_chars = { '#' => '\#',
|
||
'$' => '\$',
|
||
'%' => '\%',
|
||
'&' => '\&',
|
||
'\\' => '\textbackslash{}',
|
||
'^' => '\textasciicircum{}',
|
||
'_' => '\_',
|
||
'{' => '\{',
|
||
'}' => '\}',
|
||
'~' => '\textasciitilde{}' }
|
||
regexp_str = escape_chars.keys.map { |c| Regexp.escape(c) }.join('|')
|
||
regexp = Regexp.new(regexp_str)
|
||
string.to_s.gsub(regexp, escape_chars)
|
||
end
|
||
alias_method :l, :_escape_latex
|
||
|
||
# Generates a LaTex document for the invoice with the given number.
|
||
#
|
||
# @param [Fixnum] number number of the invoice
|
||
def _generate_invoice_tex(number)
|
||
template = TEMPLATE_DIR + "#{@config["invoice_template"]}.tex.erb"
|
||
tex_file = PUBLIC_DIR + "invoices/#{number}.tex"
|
||
|
||
I18n.with_locale :nl do
|
||
erb = ERB.new(File.read(template))
|
||
File.open(tex_file, "w") { |f| f.write(erb.result(binding)) }
|
||
end
|
||
rescue Exception => err
|
||
tex_file.delete if File.exist? tex_file
|
||
raise err
|
||
end
|
||
|
||
# Generates a PDF document for the invoice with the given number
|
||
# using {#_generate_invoice_tex}.
|
||
#
|
||
# @param [Fixnum] number number of the invoice
|
||
def _generate_invoice_pdf(number)
|
||
tex_file = PUBLIC_DIR + "invoices/#{@number}.tex"
|
||
_generate_invoice_tex(number) unless tex_file.exist?
|
||
|
||
# FIXME: remove rubber depend, use pdflatex directly
|
||
system("rubber --pdf --inplace #{tex_file}")
|
||
system("rubber --clean --inplace #{tex_file}")
|
||
end
|
||
end # class StopTime::Controllers::CustomerNInvoicesX
|
||
|
||
# == The invoice creating controller for a specifc customer
|
||
#
|
||
# Controller for creating a new invoice for a specific customer.
|
||
#
|
||
# path:: +/customers/+_customer_id_+/invoices/new+
|
||
# view:: {Views#invoice_select_form}
|
||
class CustomersNInvoicesNew
|
||
# Generates the form to create a new invoice object ({Models::Invoice})
|
||
# by listing unbilled fixed cost tasks and unbilled registered time
|
||
# (for tasks with an hourly rate) of the customer with the given
|
||
# customer ID so that it can be individually selected using
|
||
# {Views#invoice_select_form}.
|
||
#
|
||
# @param [Fixnum] customer_id ID of the customer
|
||
def get(customer_id)
|
||
@customer = Customer.find(customer_id)
|
||
@hourly_rate_tasks = {}
|
||
@fixed_cost_tasks = {}
|
||
@customer.active_tasks.each do |task|
|
||
case task.type
|
||
when "fixed_cost"
|
||
total = task.time_entries.inject(0.0) { |s, te| s + te.hours_total }
|
||
@fixed_cost_tasks[task] = total
|
||
when "hourly_rate"
|
||
time_entries = task.billable_time_entries
|
||
@hourly_rate_tasks[task] = time_entries
|
||
end
|
||
end
|
||
@none_found = @hourly_rate_tasks.empty? and @fixed_cost_tasks.empty?
|
||
render :invoice_select_form
|
||
end
|
||
end # class StopTime::Controllers::CustomersNInvoicesNew
|
||
|
||
# == The timeline controller
|
||
#
|
||
# Controller for presenting a timeline of registered time and
|
||
# also for quickly registering time.
|
||
#
|
||
# path:: +/timeline+
|
||
# view:: {Views#timeline}
|
||
class Timeline
|
||
# Retrieves all registered time in descending order to present
|
||
# the timeline using {Views#timeline}.
|
||
def get
|
||
if @input["time_entries"] == "all"
|
||
@time_entries = TimeEntry.order("start DESC")
|
||
else
|
||
@time_entries = TimeEntry.joins(:task)\
|
||
.where("stoptime_tasks.invoice_id" => nil)\
|
||
.order("start DESC")
|
||
end
|
||
@time_entries = @time_entries.where.not(task_id: nil)
|
||
@time_entries.each do |te|
|
||
@input["bill_#{te.id}"] = true if te.bill?
|
||
end
|
||
@customer_list = Customer.all.map { |c| [c.id, c.shortest_name] }
|
||
@task_list = Hash.new { |h, k| h[k] = Array.new }
|
||
Task.all.reject { |t| t.billed? }.each do |t|
|
||
@task_list[t.customer.shortest_name] << [t.id, t.name]
|
||
end
|
||
@input["bill"] = true # Bill by default.
|
||
@input["task"] = @time_entries.first.task.id if @time_entries.present?
|
||
render :timeline
|
||
end
|
||
|
||
# Registers a time entry and redirects back to the referer.
|
||
# If the provided information was invalid, the errors are retrieved.
|
||
def post
|
||
if @input.has_key? "enter"
|
||
@time_entry = TimeEntry.create(
|
||
task_id: @input.task,
|
||
date: @input.date,
|
||
start: "#{@input.date} #{@input.start}",
|
||
end: "#{@input.date} #{@input.end}",
|
||
comment: @input.comment,
|
||
bill: @input.has_key?("bill"))
|
||
# Add a day to the end date if the total hours is negative.
|
||
# It means that the end time was before the begin time, i.e.
|
||
# overnight.
|
||
@time_entry.end += 1.day if @time_entry.hours_total < 0
|
||
@time_entry.save
|
||
if @time_entry.invalid?
|
||
@errors = @time_entry.errors
|
||
end
|
||
end
|
||
redirect @request.referer
|
||
end
|
||
end # class StopTime::Controllers::Timeline
|
||
|
||
# == The timeline quick register controller
|
||
#
|
||
# Controller that presents a view for quickly registering time
|
||
# on a task.
|
||
#
|
||
# path:: +/timeline/new+
|
||
# view:: {Views#time_entry_form}
|
||
class TimelineNew
|
||
# Retrieves a list of customers and tasks and the current date
|
||
# and time for prefilling a form ({Views#time_entry_form}) for quickly
|
||
# registering time.
|
||
def get
|
||
@customer_list = Customer.all.map { |c| [c.id, c.shortest_name] }
|
||
@task_list = Hash.new { |h, k| h[k] = Array.new }
|
||
Task.all.reject { |t| t.billed? }.each do |t|
|
||
@task_list[t.customer.shortest_name] << [t.id, t.name]
|
||
end
|
||
@input["bill"] = true
|
||
date_time_new = date_time_new_entry(TimeEntry.last)
|
||
if date_time_new
|
||
@input["date"] = date_time_new.to_date.to_formatted_s
|
||
@input["start"] = date_time_new.to_formatted_s(:time_only)
|
||
end
|
||
@target = [Timeline]
|
||
@button = "enter"
|
||
render :time_entry_form
|
||
end
|
||
end # class StopTime::Controllers::TimelineNew
|
||
|
||
# == The timeline time entry controller
|
||
#
|
||
# Controller for viewing and updating information of a time entry.
|
||
#
|
||
# path:: +/timeline/+_entry_id_
|
||
# view:: {Views#time_entry_form}
|
||
class TimelineN
|
||
# Finds the time entry with the given time entry ID and shows
|
||
# a form for updating using {Views#time_entry_form}.
|
||
#
|
||
# @param [Fixnum] entry_id ID of the time entry
|
||
def get(entry_id)
|
||
@time_entry = TimeEntry.find(entry_id)
|
||
@input = @time_entry.attributes
|
||
@input["customer"] = @time_entry.task.customer.id
|
||
@input["task"] = @time_entry.task.id
|
||
@input["date"] = @time_entry.date.to_date
|
||
@input["start"] = @time_entry.start.to_formatted_s(:time_only)
|
||
@input["end"] = @time_entry.end.to_formatted_s(:time_only)
|
||
@customer_list = Customer.all.map { |c| [c.id, c.shortest_name] }
|
||
@task_list = Hash.new { |h, k| h[k] = Array.new }
|
||
Task.order("name ASC, invoice_id ASC").each do |t|
|
||
name = t.billed? ? t.name + " (#{t.invoice.number})" : t.name
|
||
@task_list[t.customer.shortest_name] << [t.id, name]
|
||
end
|
||
|
||
@target = [TimelineN, entry_id]
|
||
@button = "update"
|
||
render :time_entry_form
|
||
end
|
||
|
||
# Updates or deletes the time entry if the input is valid and redirects
|
||
# to {Timeline}.
|
||
# If the provided information is invalid, the errors are retrieved
|
||
# and shown in the initial form ({Views#time_entry_form}).
|
||
#
|
||
# @param [Fixnum] entry_id ID of the time entry
|
||
def post(entry_id)
|
||
return redirect R(Timeline) if @input.cancel
|
||
@time_entry = TimeEntry.find(entry_id)
|
||
if @input.has_key? "delete"
|
||
@time_entry.delete
|
||
elsif @input.has_key? "update"
|
||
attrs = ["date", "comment"]
|
||
attrs.each do |attr|
|
||
@time_entry[attr] = @input[attr]
|
||
end
|
||
@time_entry.start = "#{@input["date"]} #{@input["start"]}"
|
||
@time_entry.end = "#{@input["date"]} #{@input["end"]}"
|
||
@time_entry.task = Task.find(@input.task)
|
||
@time_entry.bill = @input.has_key? "bill"
|
||
# Add a day to the end date if the total hours is negative.
|
||
@time_entry.end += 1.day if @time_entry.hours_total < 0
|
||
@time_entry.save
|
||
if @time_entry.invalid?
|
||
@errors = @time_entry.errors
|
||
return render :time_entry_form
|
||
end
|
||
end
|
||
redirect @request.referer
|
||
end
|
||
end # class StopTime::Controllers::TimelineN
|
||
|
||
# == The invoices controller
|
||
#
|
||
# Controller for viewing a list of all invoices.
|
||
#
|
||
# path:: +/invoices+
|
||
# view:: {Views#invoices}
|
||
class Invoices
|
||
# Retrieves the list of invoices, sorted per customer, and displays
|
||
# them using {Views#invoices}.
|
||
def get
|
||
@invoices = {}
|
||
@invoice_count = 0
|
||
Customer.all.each do |customer|
|
||
invoices = customer.invoices
|
||
next if invoices.empty?
|
||
@invoices[customer] = invoices
|
||
invoices.each do |i|
|
||
@input["paid_#{i.number}"] = true if i.paid?
|
||
end
|
||
@invoice_count += invoices.count
|
||
end
|
||
render :invoices
|
||
end
|
||
end # class StopTime::Controllers::Invoices
|
||
|
||
# == The invoices per period controller
|
||
#
|
||
# Controller for viewing a list of all invoices sorted by period.
|
||
#
|
||
# path:: +/invoices/period+
|
||
# view:: {Views#invoices}
|
||
class InvoicesPeriod
|
||
# Retrieves the list of invoices, sorted per period, and displays
|
||
# them using {Views#invoices}.
|
||
def get
|
||
@invoices = Hash.new { |h, k| h[k] = Array.new }
|
||
Invoice.all.each do |invoice|
|
||
# FIXME: this is an unformatted key!
|
||
@invoices[invoice.period.first.at_beginning_of_month] << invoice
|
||
end
|
||
render :invoices
|
||
end
|
||
end
|
||
|
||
# == The company controller
|
||
#
|
||
# Controller for viewing and updating information of the company of
|
||
# the user (stored in Models::CompanyInfo).
|
||
#
|
||
# path:: +/company+
|
||
# view:: {Views#company_form}
|
||
class Company
|
||
# Retrieves the company information and shows a form for updating
|
||
# using {Views#company_form}.
|
||
def get
|
||
@company = if @input.revision.present?
|
||
CompanyInfo.find(@input.revision)
|
||
else
|
||
CompanyInfo.last
|
||
end
|
||
@company_last = @company == CompanyInfo.last
|
||
@input = @company.attributes
|
||
@history_warn = true if @company != CompanyInfo.last
|
||
render :company_form
|
||
end
|
||
|
||
# Updates the company information and shows the updated form
|
||
# ({Views#company_form}).
|
||
# If the provided information was invalid, the errors are retrieved.
|
||
def post
|
||
@company = if @input.revision.present?
|
||
CompanyInfo.find(@input.revision)
|
||
else
|
||
CompanyInfo.last
|
||
end
|
||
# If we are editing the current info and it is already associated
|
||
# with some invoices, create a new revision.
|
||
@history_warn = true if @company != CompanyInfo.last
|
||
if @company.id == CompanyInfo.last.id and @company.invoices.length > 0
|
||
old_company = @company
|
||
@company = old_company.dup
|
||
@company.original = old_company
|
||
end
|
||
|
||
attrs = ["name", "contact_name",
|
||
"address_street", "address_postal_code", "address_city",
|
||
"country", "country_code",
|
||
"phone", "cell", "email", "website",
|
||
"chamber", "vatno",
|
||
"bank_name", "bank_bic", "accountno", "accountiban"]
|
||
attrs.each do |attr|
|
||
@company[attr] = @input[attr]
|
||
end
|
||
@company.save
|
||
if @company.invalid?
|
||
@errors = @company.errors
|
||
end
|
||
render :company_form
|
||
end
|
||
end # class StopTime::Controllers::Company
|
||
|
||
# == The static data controller
|
||
#
|
||
# Controller for serving static data information available in the
|
||
# +public/+ subdirectory.
|
||
#
|
||
# path:: +/static/+_path_
|
||
# view:: N/A (X-Sendfile)
|
||
class Static < R '/static/(.*?)'
|
||
# Sets the headers such that the web server will fetch and offer
|
||
# the file identified by the path relative to the +public/+ subdirectory.
|
||
#
|
||
# @param [String] path the relative path to a public data file
|
||
def get(path)
|
||
unless path.include? ".."
|
||
full_path = PUBLIC_DIR + path
|
||
@headers['Content-Type'] = Rack::Mime.mime_type(full_path.extname)
|
||
@headers['X-Sendfile'] = full_path.to_s
|
||
else
|
||
@status = "403"
|
||
"Error 403: Invalid path: #{path}"
|
||
end
|
||
end
|
||
end # class StopTime::Controllers::Static
|
||
|
||
end # module StopTime::Controllers
|
||
|
||
# = The Stop… Camping Time! views
|
||
module StopTime::Views
|
||
|
||
# The main layout used by all views.
|
||
#
|
||
# @return [Mab::Mixin::Tag] the main layout
|
||
def layout
|
||
doctype!
|
||
html(lang: "en") do
|
||
head do
|
||
title "Stop… Camping Time!"
|
||
meta name: "viewport",
|
||
content: "width=device-width, initial-scale=1.0"
|
||
# Bootstrap core CSS
|
||
link rel: "stylesheet", type: "text/css", media: "screen",
|
||
href: (R(Static, "") + "stylesheets/bootstrap.min.css")
|
||
# FIXME: improve static serving so that the hack below is not needed.
|
||
link rel: "stylesheet", type: "text/css", media: "screen",
|
||
href: (R(Static, "") + "stylesheets/style.css")
|
||
# Enable responsiveness
|
||
meta name: "viewport",
|
||
content: "width=device-width, initial-scale=1, " +
|
||
"maximum-scale=1, user-scalable=no"
|
||
|
||
end
|
||
body do
|
||
_menu
|
||
div.container do
|
||
self << yield
|
||
footer { br }
|
||
end
|
||
footer.footer do
|
||
div.container do
|
||
small do
|
||
text! "Stop… Camping Time! v#{StopTime::VERSION} — by "
|
||
a "Mozcode", href: "https://mozcode.nl"
|
||
end
|
||
end
|
||
end
|
||
# JQuery and Bootstrap JavaScript
|
||
script src: (R(Static, "") + "javascripts/jquery.min.js")
|
||
script src: (R(Static, "") + "javascripts/bootstrap.min.js")
|
||
end
|
||
end
|
||
end
|
||
|
||
# The main overview showing accumulated time per task per customer.
|
||
#
|
||
# @return [Mab::Mixin::Tag] the main overview
|
||
def overview
|
||
header.page_header do
|
||
h1 do
|
||
text! "Overview"
|
||
small "#{@tasks.count} customers, " +
|
||
"#{@active_task_count} active projects/tasks"
|
||
end
|
||
end
|
||
if @tasks.empty?
|
||
div.alert.alert_info do
|
||
text! "No customers, projects or tasks found! Set them up " +
|
||
"#{a "here", href: R(CustomersNew)}."
|
||
end
|
||
else
|
||
div.row do
|
||
@tasks.keys.sort_by { |c| c.name }.each do |customer|
|
||
div.col_md_6 do
|
||
inv_klass = "text_info"
|
||
if customer.invoices.any? { |inv| inv.past_due? }
|
||
inv_klass = "text_warning"
|
||
end
|
||
if customer.invoices.any? { |inv| inv.way_past_due? }
|
||
inv_klass = "text_danger"
|
||
end
|
||
h3 do
|
||
a customer.name, class: inv_klass,
|
||
href: R(CustomersN, customer.id)
|
||
end
|
||
if @tasks[customer].empty?
|
||
p do
|
||
text! "No projects/tasks found! Create one " +
|
||
"#{a "here", href: R(CustomersNTasksNew, customer.id)}."
|
||
end
|
||
elsif @active_tasks[customer].empty?
|
||
p do
|
||
em "No active projects/tasks found! " +
|
||
"Register time on one of these projects/tasks: "
|
||
br
|
||
@tasks[customer].each do |task|
|
||
a task.name, href: R(CustomersNTasksN, customer.id, task.id)
|
||
text! "·" unless task == @tasks[customer].last
|
||
end
|
||
end
|
||
else
|
||
table.table.table_condensed do
|
||
@active_tasks[customer].each do |task|
|
||
tr do
|
||
summary = task.summary
|
||
td.col_md_4.col_xs_6 do
|
||
a task.name, href: R(CustomersNTasksN,
|
||
customer.id,
|
||
task.id)
|
||
end
|
||
summary = task.summary
|
||
td.col_md_1.col_xs_3.text_right { "%.2fh" % summary[0] }
|
||
td.col_md_1.col_xs_3.text_right { "€ %.2f" % summary[2] }
|
||
end
|
||
end
|
||
tr do
|
||
td.col_md_4.col_xs_6 { strong "Total" }
|
||
td.col_md_1.col_xs_3.text_right do
|
||
"%.2fh" % @active_tasks_summary[customer][0]
|
||
end
|
||
td.col_md_1.col_xs_3.text_right do
|
||
"€ %.2f" % @active_tasks_summary[customer][1]
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
div.row do
|
||
div.col_md_12 do
|
||
table.table.table_condensed.grand_total do
|
||
tr do
|
||
td.col_md_10.col_xs_6 { big { strong "Grand total" } }
|
||
td.col_md_1.col_xs_3.text_right do
|
||
big { strong("%.2fh" % @totals[0]) }
|
||
end
|
||
td.col_md_1.col_xs_3.text_right do
|
||
big { strong("€ %.2f" % @totals[1]) }
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
# The main overview showing the timeline of registered time.
|
||
#
|
||
# @return [Mab::Mixin::Tag] the main timeline (time entry list) overview
|
||
def timeline
|
||
header.page_header do
|
||
h1 do
|
||
text! "Timeline"
|
||
small "#{@time_entries.count} time entries"
|
||
div.btn_group.navbar_right do
|
||
a.btn.btn_default.btn_sm role: "button", href: R(TimelineNew) do
|
||
_icon("time")
|
||
span "Register time"
|
||
end
|
||
a.btn.btn_default.btn_sm.dropdown_toggle role: "button", href: "#",
|
||
data_toggle: "dropdown" do
|
||
_icon("filter")
|
||
text! @input["time_entries"] == "all" ? "All" : "Unbilled"
|
||
span.caret
|
||
end
|
||
ul.dropdown_menu role: "menu", aria_labelledby: "dLabel" do
|
||
li { a "All", href: R(Timeline, time_entries: "all") }
|
||
li { a "Unbilled", href: R(Timeline, time_entries: "unbilled") }
|
||
end
|
||
end
|
||
end
|
||
end
|
||
_time_entries
|
||
end
|
||
|
||
# Form for editing a time entry ({Models::TimeEntry}).
|
||
#
|
||
# @return [Mab::Mixin::Tag] the time entry form
|
||
def time_entry_form
|
||
header.page_header do
|
||
h1 do
|
||
text! "Time Entry Information"
|
||
small @input["comment"]
|
||
end
|
||
end
|
||
div.alert.alert_warning do
|
||
button.close(type: "button", data_dismiss: "alert") { "×" }
|
||
strong "Warning!"
|
||
text! "This time entry is already billed! Only make changes if you " +
|
||
"know what you are doing!"
|
||
end if @time_entry.present? and @time_entry.task.billed?
|
||
div.row do
|
||
div.col_md_6.col_xs_12 do
|
||
form.form_horizontal.form_condensed action: R(*@target), method: :post do
|
||
div.form_group do
|
||
label.control_label.col_sm_3.col_xs_4 "Customer", for: "customer"
|
||
div.col_sm_4.col_xs_8 do
|
||
_form_select("customer", @customer_list)
|
||
end
|
||
div.col_sm_offset_2.col_sm_3.hidden_xs do
|
||
if @time_entry.present?
|
||
a.btn.btn_default role: "button",
|
||
href: R(CustomersN, @time_entry.customer.id) do
|
||
_icon("user")
|
||
span "Show customer"
|
||
end
|
||
end
|
||
end
|
||
end
|
||
div.form_group do
|
||
label.control_label.col_sm_3.col_xs_4 "Project/Task", for: "task"
|
||
div.col_sm_6.col_xs_8 do
|
||
_form_select_nested("task", @task_list)
|
||
end
|
||
div.col_sm_3.hidden_xs do
|
||
if @time_entry.present?
|
||
a.btn.btn_default role: "button",
|
||
href: R(CustomersNTasksN,
|
||
@time_entry.customer.id,
|
||
@time_entry.task.id) do
|
||
_icon("pencil")
|
||
span "Show project/task"
|
||
end
|
||
end
|
||
end
|
||
end
|
||
if @time_entry.present? and @time_entry.task.billed?
|
||
div.form_group do
|
||
label.control_label.col_sm_3.col_xs_4 "Billed in invoice"
|
||
div.col_sm_6.col_xs_8 do
|
||
a.btn.btn_default role: "button",
|
||
href: R(CustomersNInvoicesX,
|
||
@time_entry.customer.id,
|
||
@time_entry.task.invoice.number) do
|
||
_icon("file")
|
||
span @time_entry.task.invoice.number
|
||
end
|
||
end
|
||
end
|
||
end
|
||
_form_input_with_label("Date", "date", :text,
|
||
control_class: "col-sm-3 col-xs-5")
|
||
_form_input_with_label("Start time", "start", :text,
|
||
control_class: "col-sm-2 col-xs-3")
|
||
_form_input_with_label("End time", "end", :text,
|
||
control_class: "col-sm-2 col-xs-3")
|
||
_form_input_with_label("Comment", "comment", :text,
|
||
control_class: "col-sm-6 col-xs-8")
|
||
div.form_group do
|
||
label.control_label.col_sm_3.col_xs_4 "Bill?", for: "bill"
|
||
div.col_sm_3.col_xs_5 do
|
||
div.checkbox do
|
||
_form_input_checkbox("bill")
|
||
end
|
||
end
|
||
end
|
||
div.form_group do
|
||
div.col_sm_offset_3.col_sm_6.col_xs_offset_4.col_xs_8 do
|
||
button.btn.btn_primary @button.capitalize, type: "submit",
|
||
name: @button, value: @button.capitalize
|
||
button.btn.btn_default "Cancel", type: "submit",
|
||
name: "cancel", value: "Cancel"
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
# The main overview of the list of customers.
|
||
#
|
||
# @return [Mab::Mixin::Tag] the customer list overview
|
||
def customers
|
||
header.page_header do
|
||
h1 do
|
||
text! "Customers"
|
||
small "#{@customers.count} customers"
|
||
div.btn_group.navbar_right do
|
||
a.btn.btn_default.btn_sm role: "button", href: R(CustomersNew) do
|
||
_icon("plus")
|
||
span "Add customer"
|
||
end
|
||
end
|
||
end
|
||
end
|
||
if @customers.empty?
|
||
div.alert.alert_info do
|
||
text! "None found! You can create one " +
|
||
"#{a "here", href: R(CustomersNew)}."
|
||
end
|
||
else
|
||
div.row do
|
||
div.col_md_9.col_xs_12 do
|
||
table.table.table_striped.table_condensed do
|
||
thead do
|
||
tr do
|
||
th.col_md_2.col_xs_5 "Name"
|
||
th.col_md_2.hidden_xs "Short name"
|
||
th.col_md_3.col_xs_5 "Address"
|
||
th.col_md_2.hidden_xs "Email"
|
||
th.col_md_2.hidden_xs "Phone"
|
||
th.col_md_1.col_xs_2 {}
|
||
end
|
||
end
|
||
tbody do
|
||
@customers.each do |customer|
|
||
tr do
|
||
td { a customer.name, href: R(CustomersN, customer.id) }
|
||
td.hidden_xs { customer.short_name || "–"}
|
||
td do
|
||
if customer.address_street.present?
|
||
text! customer.address_street
|
||
br
|
||
text! customer.address_postal_code + " " +
|
||
customer.address_city
|
||
if customer.email.present?
|
||
a.visible_xs customer.email,
|
||
href: "mailto:#{customer.email}"
|
||
end
|
||
if customer.phone.present?
|
||
# FIXME: hardcoded prefix!
|
||
span.visible_xs "0#{customer.phone}"
|
||
end
|
||
else
|
||
"–"
|
||
end
|
||
end
|
||
td.hidden_xs do
|
||
if customer.email.present?
|
||
a customer.email, href: "mailto:#{customer.email}"
|
||
else
|
||
"–"
|
||
end
|
||
end
|
||
td.hidden_xs do
|
||
if customer.phone.present?
|
||
# FIXME: hardcoded prefix!
|
||
"0#{customer.phone}"
|
||
else
|
||
"–"
|
||
end
|
||
end
|
||
td do
|
||
form action: R(CustomersN, customer.id), method: :post do
|
||
button.btn.btn_xs.btn_danger "Delete", type: :submit,
|
||
name: "delete", value: "Delete"
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
# Form for editing the properties of customer ({Models::Customer}) but also
|
||
# for adding/editing/deleting tasks and showing a list of invoices for
|
||
# the customer.
|
||
#
|
||
# @return [Mab::Mixin::Tag] the customer form
|
||
def customer_form
|
||
header.page_header do
|
||
h1 do
|
||
text! "Customer Information"
|
||
small @input["name"]
|
||
end
|
||
end
|
||
div.row do
|
||
div.col_md_6 do
|
||
h2 "Details"
|
||
form.form_horizontal.form_condensed action: R(*@target),
|
||
method: :post do
|
||
_form_input_with_label("Name", "name", :text,
|
||
control_class: "col-sm-6 col-xs-8")
|
||
_form_input_with_label("Short name", "short_name", :text,
|
||
control_class: "col-sm-4 col-xs-6")
|
||
_form_input_with_label("Street address", "address_street", :text,
|
||
control_class: "col-sm-6 col-xs-8")
|
||
_form_input_with_label("Postal code", "address_postal_code", :text,
|
||
control_class: "col-sm-3 col-xs-4")
|
||
_form_input_with_label("City/town", "address_city", :text,
|
||
control_class: "col-sm-6 col-xs-8")
|
||
_form_input_with_label("Email address", "email", :email,
|
||
control_class: "col-sm-6 col-xs-8")
|
||
_form_input_with_label("Phone number", "phone", :tel,
|
||
control_class: "col-sm-3 col-xs-4")
|
||
_form_input_with_label("Financial contact", "financial_contact", :text,
|
||
control_class: "col-sm-6 col-xs-8")
|
||
_form_input_with_label("Default hourly rate", "hourly_rate", :number,
|
||
control_class: "col-sm-4 col-xs-5",
|
||
input_addon: "€ / h",
|
||
min: "0.00",
|
||
step: "0.01")
|
||
div.form_group do
|
||
label.control_label.col_sm_3.col_xs_4 "Time specifications?"
|
||
div.col_sm_6.col_xs_8 do
|
||
div.checkbox do
|
||
_form_input_checkbox("time_specification")
|
||
end
|
||
end
|
||
end
|
||
div.form_group do
|
||
div.col_sm_offset_3.col_sm_6.col_xs_offset_4.col_xs_8 do
|
||
button.btn.btn_primary @button.capitalize, type: "submit",
|
||
name: @button, value: @button.capitalize
|
||
button.btn.btn_default "Cancel", type: "submit",
|
||
name: "cancel", value: "Cancel"
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
div.col_md_6 do
|
||
if @edit_task
|
||
h2 do
|
||
text! "Projects & Tasks"
|
||
div.btn_group.navbar_right do
|
||
a.btn.btn_default.btn_sm role: "button",
|
||
href: R(CustomersNTasksNew, @customer.id) do
|
||
_icon("plus")
|
||
span "Add project/task"
|
||
end
|
||
end
|
||
end
|
||
if @billed_tasks.empty?
|
||
p { em "None found!" }
|
||
else
|
||
div.accordion.task_list! do
|
||
@billed_tasks.keys.sort_by { |task| task.name }.each do |task|
|
||
div.panel.panel_default do
|
||
div.panel_heading role: "tab", id: "heading#{task.id}" do
|
||
h3.panel_title do
|
||
a task.name, data_toggle: "collapse",
|
||
data_parent: "#task_list",
|
||
aria_expanded: true,
|
||
aria_controls: "#collapse#{task.id}",
|
||
role: "button",
|
||
href: "#collapse#{task.id}"
|
||
# FXIME: the following is not very RESTful!
|
||
form.form_inline.pull_right action: R(CustomersNTasks,
|
||
@customer.id),
|
||
method: :post do
|
||
a.btn.btn_default.btn_xs "Edit", role: "button",
|
||
href: R(CustomersNTasksN, @customer.id, task.id)
|
||
input type: :hidden, name: "task_id", value: task.id
|
||
button.btn.btn_danger.btn_xs "Delete", type: :submit,
|
||
name: "delete", value: "Delete"
|
||
end
|
||
end
|
||
end
|
||
div.panel_collapse.collapse role: "tabpanel",
|
||
id: "collapse#{task.id}" do
|
||
div.panel_body do
|
||
if @billed_tasks[task].empty?
|
||
em { "No billed projects/tasks found!" }
|
||
else
|
||
table.table.table_condensed do
|
||
@billed_tasks[task] \
|
||
.sort_by { |t| t.invoice.number } \
|
||
.each do |billed_task|
|
||
tr do
|
||
td.col_md_9 do
|
||
a billed_task.comment_or_name,
|
||
href: R(CustomersNTasksN,
|
||
@customer.id,
|
||
billed_task.id)
|
||
small do
|
||
text! "(billed in invoice "
|
||
a billed_task.invoice.number,
|
||
title: billed_task.invoice.number,
|
||
href: R(CustomersNInvoicesX,
|
||
@customer.id,
|
||
billed_task.invoice.number)
|
||
text! ")"
|
||
end
|
||
end
|
||
td.col_md_3 do
|
||
# FXIME: the following is not very RESTful!
|
||
form.form_inline.pull_right \
|
||
action: R(CustomersNTasks, @customer.id),
|
||
method: :post do
|
||
a.btn.btn_default.btn_xs "Edit",
|
||
href: R(CustomersNTasksN,
|
||
@customer.id,
|
||
billed_task.id),
|
||
role: "button"
|
||
input type: :hidden, name: "task_id",
|
||
value: billed_task.id
|
||
button.btn.btn_danger.btn_xs "Delete",
|
||
type: :submit, name: "delete",
|
||
value: "Delete"
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
h2 do
|
||
text! "Invoices"
|
||
div.btn_group.navbar_right do
|
||
a.btn.btn_default.btn_sm role: "button",
|
||
href: R(CustomersNInvoicesNew, @customer.id) do
|
||
_icon("plus")
|
||
span "Create invoice"
|
||
end
|
||
end
|
||
end
|
||
_invoice_list(@invoices)
|
||
end
|
||
end
|
||
end
|
||
|
||
# Show registered time using the time_entries view as partial view.
|
||
div.row do
|
||
div.col_xs_12 do
|
||
h2.timeline! "Registered unbilled time"
|
||
_time_entries(@customer)
|
||
end
|
||
end unless @button == "create"
|
||
end
|
||
|
||
# Form for updating the properties of a task ({Models::Task}).
|
||
#
|
||
# @return [Mab::Mixin::Tag] the task form
|
||
def task_form
|
||
header.page_header do
|
||
h1 do
|
||
text! "Task Information"
|
||
small @task.name
|
||
end
|
||
end
|
||
div.alert.alert_warning do
|
||
button.close(type: "button", data_dismiss: "alert") { "×" }
|
||
strong "Warning!"
|
||
text! "This task is already billed! Only make changes if you know " +
|
||
"what you are doing!"
|
||
end if @task.billed?
|
||
div.row do
|
||
div.col_md_6.col_xs_12 do
|
||
form.form_horizontal.form_condensed action: R(*@target),
|
||
method: :post do
|
||
div.form_group do
|
||
label.control_label.col_sm_3.col_xs_4 "Customer", for: "customer"
|
||
div.col_sm_4.col_xs_8 do
|
||
_form_select("customer", @customer_list)
|
||
end
|
||
div.col_sm_offset_2.col_sm_3.hidden_xs do
|
||
a.btn.btn_default role: "button",
|
||
href: R(CustomersN, @customer.id) do
|
||
_icon("user")
|
||
span "Show customer"
|
||
end
|
||
end
|
||
end
|
||
_form_input_with_label("Name", "name", :text)
|
||
div.form_group do
|
||
label.control_label.col_sm_3.col_xs_4 "Project/Task type"
|
||
div.col_sm_5.col_xs_8 do
|
||
div.radio do
|
||
label do
|
||
_form_input_radio("type", "hourly_rate", true)
|
||
text!("Hourly rate: ")
|
||
div.input_group do
|
||
_form_input("hourly_rate", :number, "Hourly rate",
|
||
min: "0.00", step: "0.01")
|
||
span.input_group_addon "€ / h"
|
||
end
|
||
end
|
||
end
|
||
div.radio do
|
||
label do
|
||
_form_input_radio("type", "fixed_cost")
|
||
text!("Fixed cost: ")
|
||
div.input_group do
|
||
_form_input("fixed_cost", :number, "Fixed cost",
|
||
min: "0.00", step: "0.01")
|
||
span.input_group_addon "€"
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
_form_input_with_label("VAT rate", "vat_rate", :number,
|
||
control_class: "col-lg-3 col-sm-4 col-xs-6",
|
||
input_addon: "%")
|
||
if @task.billed?
|
||
div.form_group do
|
||
label.control_label.col_sm_3.col_xs_4 "Billed in invoice"
|
||
div.col_sm_6.col_xs_8 do
|
||
a.btn.btn_default role: "button",
|
||
href: R(CustomersNInvoicesX,
|
||
@customer.id, @task.invoice.number) do
|
||
_icon("file")
|
||
span @task.invoice.number
|
||
end
|
||
end
|
||
end
|
||
_form_input_with_label("Invoice comment", "invoice_comment", :text)
|
||
end
|
||
div.form_group do
|
||
div.col_sm_offset_3.col_sm_6.col_xs_offset_4.col_xs_8 do
|
||
button.btn.btn_primary @method.capitalize,
|
||
type: "submit", name: @method, value: @method.capitalize
|
||
button.btn.btn_default "Cancel", type: "submit",
|
||
name: "cancel", value: "Cancel"
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
# Show registered time (ab)using the time_entries view as partial view.
|
||
div.row do
|
||
div.col_md_8.col_xs_12 do
|
||
h2.timeline! "Registered #{@task.billed? ? "billed" : "unbilled"} time"
|
||
_time_entries(@customer, @task)
|
||
end
|
||
end unless @method == "create"
|
||
end
|
||
|
||
# The main overview of the existing invoices.
|
||
#
|
||
# @return [Mab::Mixin::Tag] the invoices list overview
|
||
def invoices
|
||
header.page_header do
|
||
h1 do
|
||
text! "Invoices"
|
||
small "#{@invoices.count} customers, #{@invoice_count} invoices"
|
||
end
|
||
end
|
||
if @invoices.values.flatten.empty?
|
||
div.alert.alert_info do
|
||
text! "Found none! You can create one by " +
|
||
"#{a "selecting a customer", href: R(Customers)}."
|
||
end
|
||
else
|
||
div.row do
|
||
@invoices.keys.sort.each do |customer|
|
||
div.col_md_6 do
|
||
next if @invoices[customer].empty?
|
||
h2 do
|
||
text! customer.name
|
||
div.btn_group.navbar_right do
|
||
a.btn.btn_default.btn_sm role: "button",
|
||
href: R(CustomersNInvoicesNew, customer.id) do
|
||
_icon("plus")
|
||
span "Create invoice"
|
||
end
|
||
end
|
||
end
|
||
_invoice_list(@invoices[customer])
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
# A view displaying the information (billed tasks and time) of an
|
||
# invoice ({Models::Invoice}) that also allows for updating the "+paid+"
|
||
# property.
|
||
#
|
||
# @return [Mab::Mixin::Tag] the invoice form
|
||
def invoice_form
|
||
header.page_header do
|
||
h1 do
|
||
text! "Invoice for "
|
||
a @customer.name, href: R(CustomersN, @customer.id)
|
||
small @invoice.number
|
||
end
|
||
end
|
||
div.row do
|
||
div.col_md_6.col_xs_12 do
|
||
h2 "Details"
|
||
form.form_horizontal.form_condensed \
|
||
action: R(CustomersNInvoicesX, @customer.id, @invoice.number),
|
||
method: :post do
|
||
_form_input_with_label("Number", "number", :text, disabled: true,
|
||
control_class: "col-sm-3 col-xs-4")
|
||
div.form_group do
|
||
label.control_label.col_sm_3.col_xs_4 "Date"
|
||
div.col_sm_3.col_xs_4 do
|
||
input.form_control type: :text, name: "created_at",
|
||
id: "created_at",
|
||
value: @invoice.created_at.to_formatted_s(:date_only),
|
||
placeholder: "Date", disabled: true
|
||
end
|
||
end
|
||
div.form_group do
|
||
label.control_label.col_sm_3.col_xs_4 "Period"
|
||
div.col_sm_6.col_xs_8 do
|
||
input.form_control type: :text, name: "period",
|
||
id: "period",
|
||
value: _format_period(@invoice.period),
|
||
placeholder: "Period", disabled: true
|
||
end
|
||
end
|
||
div.form_group do
|
||
label.control_label.col_sm_3.col_xs_4 "Paid?"
|
||
div.checkbox do
|
||
label { _form_input_checkbox("paid") }
|
||
end
|
||
end
|
||
div.form_group do
|
||
label.control_label.col_sm_3.col_xs_4 "Include specification?"
|
||
div.checkbox do
|
||
label { _form_input_checkbox("include_specification") }
|
||
end
|
||
end
|
||
div.form_group do
|
||
div.col_sm_offset_3.col_sm_6.col_xs_offset_4.col_xs_8 do
|
||
button.btn.btn_primary "Update", type: :submit,
|
||
name: "update", value: "Update"
|
||
button.btn.btn_default "Reset", type: :reset,
|
||
name: "reset", value: "Reset"
|
||
end
|
||
end
|
||
end
|
||
end
|
||
div.col_md_6.col_xs_12 do
|
||
h2 "Billed time"
|
||
table.table.table_condensed.table_striped do
|
||
thead do
|
||
tr do
|
||
th.col_md_6 { "Project/Task" }
|
||
th.col_md_2.text_right { "Registered" }
|
||
th.col_md_2.text_right { "Hourly rt." }
|
||
th.col_md_2.text_right { "Amount" }
|
||
end
|
||
end
|
||
tbody do
|
||
subtotal = 0.0
|
||
@tasks.each do |task, line|
|
||
tr do
|
||
td.col_md_6 do
|
||
a task.comment_or_name, title: task.comment_or_name,
|
||
href: R(CustomersNTasksN,
|
||
task.customer.id, task.id)
|
||
end
|
||
if line[1].blank?
|
||
# FIXME: information of time spent is available in the summary
|
||
# but show it?
|
||
td.col_md_2.text_right { "%.2fh" % line[0] }
|
||
td.col_md_2.text_right "–"
|
||
else
|
||
td.col_md_2.text_right { "%.2fh" % line[0] }
|
||
td.col_md_2.text_right { "€ %.2f" % line[1] }
|
||
end
|
||
td.col_md_2.text_right { "€ %.2f" % line[2] }
|
||
end
|
||
subtotal += line[2]
|
||
task.time_entries.each do |entry|
|
||
tr do
|
||
td.col_md_6.indent do
|
||
time_spec =
|
||
"from #{entry.start.to_formatted_s(:time_only)} " +
|
||
"until #{entry.end.to_formatted_s(:time_only)} " +
|
||
"on #{entry.date.to_date}"
|
||
if entry.comment.present?
|
||
a "• #{entry.comment}",
|
||
href: R(TimelineN, entry.id),
|
||
title: "#{entry.comment} (#{time_spec})"
|
||
else
|
||
a(href: R(TimelineN, entry.id),
|
||
title: time_spec) { em "• None" }
|
||
end
|
||
end
|
||
td.col_md_2.text_right { "%.2fh" % entry.hours_total }
|
||
td.col_md_2.text_right { "–" }
|
||
td.col_md_2.text_right { "–" }
|
||
end
|
||
end unless task.fixed_cost?
|
||
end
|
||
vattotal = 0.0
|
||
if @company.vatno.present?
|
||
tr.total do
|
||
td { em "Sub-total" }
|
||
td ""
|
||
td ""
|
||
td.text_right { "€ %.2f" % subtotal }
|
||
end
|
||
@vat.keys.sort.each do |rate|
|
||
vattotal += @vat[rate]
|
||
tr do
|
||
td { em "VAT %d%%" % rate }
|
||
td ""
|
||
td ""
|
||
td.text_right { "€ %.2f" % @vat[rate] }
|
||
end
|
||
end
|
||
end
|
||
tr.total do
|
||
td { strong "Total" }
|
||
td ""
|
||
td ""
|
||
td.text_right { "€ %.2f" % (subtotal + vattotal) }
|
||
end
|
||
end
|
||
end
|
||
|
||
div.btn_group do
|
||
a.btn.btn_primary role: "button",
|
||
href: R(CustomersNInvoicesX,
|
||
@customer.id, "#{@invoice.number}.pdf") do
|
||
_icon("download")
|
||
span "Download PDF"
|
||
end
|
||
a.btn.btn_default role: "button",
|
||
href: R(CustomersNInvoicesX,
|
||
@customer.id, "#{@invoice.number}.tex") do
|
||
_icon("download")
|
||
span "Download LaTeX"
|
||
end
|
||
a.btn.btn_default role: "button",
|
||
href: R(Company, revision: @company.revision) do
|
||
_icon("briefcase")
|
||
span "Show company info"
|
||
end
|
||
end
|
||
|
||
div.alert.alert_danger do
|
||
form.form_inline action: R(CustomersNInvoicesX,
|
||
@customer.id, @invoice.number),
|
||
method: :delete do
|
||
button.btn.btn_danger type: "submit" do
|
||
_icon("trash")
|
||
span "Remove old"
|
||
end
|
||
text! "An invoice has already been generated!"
|
||
end
|
||
end if @invoice_file_present
|
||
end
|
||
end
|
||
end
|
||
|
||
# Form for selecting fixed cost tasks and registered time for tasks with
|
||
# an hourly rate that need to be billed.
|
||
#
|
||
# @return [Mab::Mixin::Tag] the invoice construction form
|
||
def invoice_select_form
|
||
header.page_header do
|
||
h1 do
|
||
text! "Create Invoice for "
|
||
a @customer.name, href: R(CustomersN, @customer.id)
|
||
end
|
||
end
|
||
div.row do
|
||
div.col_md_10.col_xs_12 do
|
||
if @none_found
|
||
div.alert.alert_info do
|
||
em "No fixed costs tasks or tasks with an hourly rate found!"
|
||
end
|
||
end
|
||
form.form_horizontal action: R(CustomersNInvoices, @customer.id),
|
||
method: :post do
|
||
unless @hourly_rate_tasks.empty?
|
||
h3 "Projects/Tasks with an Hourly Rate"
|
||
table.table.table_striped.table_condensed do
|
||
thead do
|
||
tr do
|
||
th.col_md_1 "Bill?"
|
||
th.col_md_2 "Date"
|
||
th.col_md_1 "Start"
|
||
th.col_md_1 "End"
|
||
th.col_md_4 "Comment"
|
||
th.col_md_1.text_right "Total"
|
||
th.col_md_2.text_right "Amount"
|
||
end
|
||
end
|
||
tbody do
|
||
@hourly_rate_tasks.keys.each do |task|
|
||
tr.info do
|
||
td.col_md_1 do
|
||
label.checkbox do
|
||
_form_input_checkbox("tasks[]", task.id, true)
|
||
end
|
||
end
|
||
td.col_md_2 colspan: 3 do
|
||
label.control_label { task.name }
|
||
end
|
||
td.col_md_1 do
|
||
input.form_control.input_sm type: :text,
|
||
name: "task_#{task.id}_comment", value: task.name,
|
||
id: "tasks_#{task.id}_comment"
|
||
end
|
||
td.col_md_1 {}
|
||
td.col_md_2 {}
|
||
end
|
||
@hourly_rate_tasks[task].each do |entry|
|
||
tr do
|
||
td.col_md_1.indent do
|
||
label.checkbox do
|
||
_form_input_checkbox("time_entries[]", entry.id,
|
||
!entry.in_current_month?)
|
||
end
|
||
end
|
||
td.col_md_2 do
|
||
label.control_label entry.date.to_date,
|
||
for: "time_entries[]_#{entry.id}"
|
||
end
|
||
td.col_md_1 do
|
||
label.control_label do
|
||
entry.start.to_formatted_s(:time_only)
|
||
end
|
||
end
|
||
td.col_md_1 do
|
||
label.control_label do
|
||
entry.end.to_formatted_s(:time_only)
|
||
end
|
||
end
|
||
td.col_md_4 do
|
||
label.control_label do
|
||
a entry.comment, href: R(TimelineN, entry.id),
|
||
title: entry.comment
|
||
end
|
||
end
|
||
td.col_md_1.text_right do
|
||
label.control_label { "%.2fh" % entry.hours_total }
|
||
end
|
||
td.col_md_2.text_right do
|
||
label.control_label do
|
||
"€ %.2f" %
|
||
(entry.hours_total * entry.task.hourly_rate)
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
unless @fixed_cost_tasks.empty?
|
||
h3 "Fixed Cost Projects/Tasks"
|
||
table.table.table_striped.table_condensed do
|
||
thead do
|
||
tr do
|
||
th.col_md_1 "Bill?"
|
||
th.col_md_4 "Project/Task"
|
||
th.col_md_4 "Comment"
|
||
th.col_md_1.text_right "Registered time"
|
||
th.col_md_2.text_right "Amount"
|
||
end
|
||
end
|
||
tbody do
|
||
@fixed_cost_tasks.keys.each do |task|
|
||
tr do
|
||
td.col_md_1 do
|
||
label.checkbox do
|
||
_form_input_checkbox("tasks[]", task.id, true)
|
||
end
|
||
end
|
||
td.col_md_4 do
|
||
label.control_label task.name, for: "tasks[]_#{task.id}"
|
||
end
|
||
td.col_md_4 do
|
||
input.form_control.input_sm type: :text,
|
||
name: "task_#{task.id}_comment",
|
||
value: task.name, class: "form-control",
|
||
id: "tasks_#{task.id}_comment"
|
||
end
|
||
td.col_md_1.text_right do
|
||
label.control_label do
|
||
"%.2fh" % @fixed_cost_tasks[task]
|
||
end
|
||
end
|
||
td.col_md_2.text_right do
|
||
label.control_label { task.fixed_cost }
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
div.form_group do
|
||
div.col_md_12 do
|
||
button.btn.btn_primary "Create invoice", type: :submit,
|
||
name: "create", value: "Create invoice",
|
||
disabled: @none_found
|
||
button.btn.btn_default "Cancel", type: :submit, name: "cancel",
|
||
value: "Cancel"
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
# Form for editing the company information ({Models::CompanyInfo}).
|
||
#
|
||
# @return [Mab::Mixin::Tag] the company information form
|
||
def company_form
|
||
header.page_header do
|
||
h1 do
|
||
text! "Company Information"
|
||
small @company.name
|
||
end
|
||
end
|
||
div.alert.alert_danger do
|
||
button.close(type: "button", data_dismiss: "alert") { "×" }
|
||
h4 "There were #{@errors.count} errors in the form!"
|
||
ul do
|
||
@errors.each do |attrib, msg|
|
||
li "#{attrib.to_s.capitalize} #{msg}"
|
||
end
|
||
end
|
||
end if @errors
|
||
div.alert.alert_info do
|
||
text! " Viewing revision #{@company.revision}, " +
|
||
" last update at #{@company.updated_at}."
|
||
div.btn_group do
|
||
if @company.original.present?
|
||
a.btn.btn_default role: "button",
|
||
href: R(Company, revision: @company.original.revision) do
|
||
_icon("backward")
|
||
span "View previous revision"
|
||
end
|
||
end
|
||
unless @company_last
|
||
a.btn.btn_default role: "button",
|
||
href: R(Company, revision: @company.revision.succ) do
|
||
_icon("forward")
|
||
span "View next revision"
|
||
end
|
||
a.btn.btn_default role: "button",
|
||
href: R(Company) do
|
||
_icon("fast-forward")
|
||
span "Most recent revision"
|
||
end
|
||
end
|
||
end
|
||
end
|
||
div.alert.alert_warning do
|
||
button.close(type: "button", data_dismiss: "alert") { "×" }
|
||
h4 "Warning!"
|
||
text! "This company information is already associated with invoices!"
|
||
br
|
||
text! "Only make changes if you know what you are doing!"
|
||
end if @history_warn
|
||
div.row do
|
||
div.col_md_8.col_xs_12 do
|
||
form.form_horizontal.form_condensed \
|
||
action: R(Company, revision: @company.revision),
|
||
method: :post do
|
||
_form_input_with_label("Name", "name", :text,
|
||
control_class: "col-sm-6 col-xs-8")
|
||
_form_input_with_label("Contact name", "contact_name", :text,
|
||
control_class: "col-sm-6 col-xs-8")
|
||
_form_input_with_label("Street address", "address_street", :text,
|
||
control_class: "col-sm-6 col-xs-8")
|
||
_form_input_with_label("Postal code", "address_postal_code", :text,
|
||
control_class: "col-sm-3 col-xs-4")
|
||
_form_input_with_label("City/town", "address_city", :text,
|
||
control_class: "col-sm-6 col-xs-8")
|
||
_form_input_with_label("Phone number", "phone", :tel,
|
||
control_class: "col-sm-3 col-xs-4")
|
||
_form_input_with_label("Cellular number", "cell", :tel,
|
||
control_class: "col-sm-3 col-xs-4")
|
||
_form_input_with_label("Email address", "email", :email,
|
||
control_class: "col-sm-6 col-xs-8")
|
||
_form_input_with_label("Web address", "website", :url,
|
||
control_class: "col-sm-6 col-xs-8")
|
||
|
||
h3 "Corporate information"
|
||
_form_input_with_label("Chamber number", "chamber", :text,
|
||
control_class: "col-sm-3 col-xs-4")
|
||
_form_input_with_label("VAT number", "vatno", :text,
|
||
control_class: "col-sm-5 col-xs-6")
|
||
|
||
h3 "Bank information"
|
||
_form_input_with_label("Name", "bank_name", :text,
|
||
control_class: "col-sm-4 col-xs-5")
|
||
_form_input_with_label("Identification code", "bank_bic", :text,
|
||
control_class: "col-sm-3 col-xs-4")
|
||
_form_input_with_label("Account holder", "accountname", :text)
|
||
_form_input_with_label("Account number", "accountno", :text,
|
||
control_class: "col-sm-5 col-xs-6")
|
||
_form_input_with_label("Intl. account number", "accountiban", :text,
|
||
control_class: "col-sm-5 col-xs-6")
|
||
|
||
div.form_group do
|
||
div.col_sm_offset_3.col_sm_6.col_xs_offset_4.col_xs_8 do
|
||
button.btn.btn_primary "Update", type: "submit",
|
||
name: "update", value: "Update"
|
||
button.btn.btn_default "Reset", type: :reset,
|
||
name: "reset", value: "Reset"
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
###############
|
||
# Partial views
|
||
#
|
||
private
|
||
|
||
# Parial view that generates an icon.
|
||
#
|
||
# @return [Mab::Mixin::Tag] the icon
|
||
def _icon(name)
|
||
span.glyphicon.send("glyphicon_#{name}", { aria_hidden: true })
|
||
end
|
||
|
||
# Partial view that generates the menu.
|
||
#
|
||
# @return [Mab::Mixin::Tag] the main menu
|
||
def _menu
|
||
nav.navbar.navbar_inverse.navbar_fixed_top do
|
||
div.container do
|
||
div.navbar_header do
|
||
button.navbar_toggle.collapsed(data_toggle: "collapse",
|
||
data_target: "#menu",
|
||
aria_expanded: false) do
|
||
span.sr_only "Toggle navigation"
|
||
span.icon_bar {}
|
||
span.icon_bar {}
|
||
span.icon_bar {}
|
||
end
|
||
a.navbar_brand(href: R(Index)) { "Stop… Camping Time!" }
|
||
end
|
||
div.navbar_collapse.collapse.menu! do
|
||
ul.nav.navbar_nav do
|
||
[["Overview", Index],
|
||
["Timeline", Timeline],
|
||
["Customers", Customers],
|
||
["Invoices", Invoices],
|
||
["Company", Company]].each do |label, ctrl|
|
||
_menu_link(label, ctrl)
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
# Partial view that generates the menu link and determines the active
|
||
# menu item.
|
||
#
|
||
# @param [String] label menu item label
|
||
# @param [Object] ctrl menu item target controller
|
||
# @return [Mab::Mixin::Tag] a menu item link tag
|
||
def _menu_link(label, ctrl)
|
||
# FIXME: dirty hack?
|
||
if self.class.to_s.match(/^#{ctrl.to_s}/)
|
||
li.active { a label, href: R(ctrl) }
|
||
else
|
||
li { a label, href: R(ctrl) }
|
||
end
|
||
end
|
||
|
||
# Partial view that generates a list of invoices.
|
||
#
|
||
# @param [Array<Invoice>] invoices list of invoices
|
||
# @return [Mab::Mixin::Tag] a list of invoices
|
||
def _invoice_list(invoices)
|
||
if invoices.empty?
|
||
p { em "None found!" }
|
||
else
|
||
table.table.table_striped.table_condensed do
|
||
thead do
|
||
tr do
|
||
th.col_md_2.col_xs_3 "Number"
|
||
th.col_md_2.hidden_xs "Date"
|
||
th.col_md_5.col_xs_5 "Period"
|
||
th.col_md_2.col_xs_3.text_right "Amount"
|
||
th.col_md_1.col_xs_1 "Paid?"
|
||
end
|
||
end
|
||
tbody do
|
||
invoices.each do |invoice|
|
||
due_class = invoice.past_due? ? "warning" : ""
|
||
due_class = "danger" if invoice.way_past_due?
|
||
tr(class: due_class) do
|
||
td do
|
||
a invoice.number,
|
||
href: R(CustomersNInvoicesX,
|
||
invoice.customer.id, invoice.number)
|
||
end
|
||
td.hidden_xs { invoice.created_at.to_formatted_s(:date_only) }
|
||
td { _format_period(invoice.period) }
|
||
td.text_right { "€ %.2f" % invoice.total_amount }
|
||
td do
|
||
_icon("ok") if invoice.paid?
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
# Partial view for formatting the period of an invoice.
|
||
#
|
||
# @param [Array(Time), Array(Time, Time)] period invoice period
|
||
# @return [String] formatted period of an invoice
|
||
def _format_period(period)
|
||
period = period.map { |m| m.to_formatted_s(:month_and_year) }.uniq
|
||
case period.length
|
||
when 1
|
||
period.first
|
||
when 2
|
||
period.join("–")
|
||
end
|
||
end
|
||
|
||
# Partial view that generates a form input.
|
||
#
|
||
# @param [String] input_name name of the input
|
||
# @param [String] type type of the input
|
||
# @param [String] placeholder placeholder text
|
||
# @param [Hash] html_options options passed on to the resulting
|
||
# Markaby/Mab tag
|
||
# @return [Mab::Mixin::Tag] a form input tag
|
||
def _form_input(input_name, type, placeholder, html_options={})
|
||
html_class = html_options.delete(:class)
|
||
html_options.merge!(type: type, name: input_name, id: input_name,
|
||
value: @input[input_name],
|
||
class: "form-control #{html_class}",
|
||
placeholder: placeholder)
|
||
input(html_options)
|
||
end
|
||
|
||
# Partial view that generates a form label and a form input, such that
|
||
# the label is linked to the input.
|
||
#
|
||
# @param [String] label_name label for the input
|
||
# @param [String] input_name name of the input
|
||
# @param [String] type type of the input
|
||
# @param [Hash] html_options options passed on to the resulting
|
||
# Markaby/Mab tag
|
||
# @return [Mab::Mixin::Tag] a form input tag
|
||
def _form_input_with_label(label_name, input_name, type, html_options={})
|
||
controls_class = html_options.delete(:control_class) || "col-sm-6 col-xs-8"
|
||
label_class = html_options.delete(:label_class) || "col-sm-3 col-xs-4"
|
||
input_addon = html_options.delete(:input_addon)
|
||
div.form_group do
|
||
label.control_label(label_name,
|
||
class: "control-label #{label_class}",
|
||
for: input_name)
|
||
div(class: controls_class) do
|
||
if input_addon
|
||
div.input_group do
|
||
_form_input(input_name, type, label_name, html_options)
|
||
span.input_group_addon input_addon
|
||
end
|
||
else
|
||
_form_input(input_name, type, label_name, html_options)
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
# Partial view that generates a form radio button.
|
||
#
|
||
# @param [String] name name of the radio button
|
||
# @param [String] value value of the radio button
|
||
# @param [Boolean] default whether the radio button is initially selected
|
||
# @param [Array] opts additional Markaby/Mab tag options
|
||
# @return [Mab::Mixin::Tag] a form radio button input tag
|
||
def _form_input_radio(name, value, default=false, *opts)
|
||
input_val = @input[name]
|
||
if input_val == value or (input_val.blank? and default)
|
||
input({ type: "radio", id: "#{name}_#{value}", name: name,
|
||
value: value, checked: true }, *opts)
|
||
else
|
||
input({ type: "radio", id: "#{name}_#{value}", name: name,
|
||
value: value }, *opts)
|
||
end
|
||
end
|
||
|
||
# Partial view that generates a form checkbox.
|
||
# Whether it is initially checked is determined by the _default_ flag.
|
||
# Additional options can be passed via the collection _opts_.
|
||
#
|
||
# @param [String] name name of the checkbox
|
||
# @param [Boolean] value whether the checkbox is checked
|
||
# @param [Boolean] default whether the checkbox is initially checked
|
||
# @param [Array] opts additional Markaby/Mab tag options
|
||
# @return [Mab::Mixin::Tag] a form checkbox input tag
|
||
def _form_input_checkbox(name, value=true, default=false, *opts)
|
||
if @input[name] == value or default
|
||
input({ type: "checkbox", id: "#{name}_#{value}", name: name,
|
||
value: value, checked: true }, *opts)
|
||
else
|
||
input({ type: "checkbox", id: "#{name}_#{value}", name: name,
|
||
value: value }, *opts)
|
||
end
|
||
end
|
||
|
||
# Partial view that generates a form select element.
|
||
#
|
||
# The option list is an Array of a 2-valued array containg a value label
|
||
# and a human readable description for the value.
|
||
#
|
||
# @param [String] name name of the form select element
|
||
# @param [Array(String, String)] opts_list list of options (value and
|
||
# description)
|
||
# @param [Hash] html_options options passed on to the resulting
|
||
# Markaby/Mab tag
|
||
# @return [Mab::Mixin::Tag] a form select input tag
|
||
def _form_select(name, opts_list, html_options={})
|
||
html_class = html_options.delete(:class)
|
||
if opts_list.blank?
|
||
html_options.merge!(name: name, id: name,
|
||
class: "form-control", disabled: true)
|
||
select(html_options) do
|
||
option "None found", value: "none", selected: true
|
||
end
|
||
else
|
||
html_options.merge!(name: name, id: name,
|
||
class: "form-control #{html_class}")
|
||
select(html_options) do
|
||
opts_list.sort_by { |o| o.last }.each do |opt_val, opt_str|
|
||
if @input[name] == opt_val
|
||
option opt_str, value: opt_val, selected: true
|
||
else
|
||
option opt_str, value: opt_val
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
# Partial view similar to {Views#_form_select} that generates a (nested)
|
||
# select element for a form.
|
||
#
|
||
# In this case, the option lists represents a subdivision of the options,
|
||
# where the key is the name of the subdivision and the value the options
|
||
# list as in {Views#_form_select}.
|
||
#
|
||
# So, the option list is an Hash of Strings mapping to Arrays of a
|
||
# 2-valued array containg a value label and a human readable description
|
||
# for the value.
|
||
#
|
||
# @param [String] name name of the form select element
|
||
# @param [Hash{String=>Array(String, String)}] opts list of options
|
||
# (section name to value and description)
|
||
# @param [Hash] html_options options passed on to the resulting
|
||
# Markaby/Mab tag
|
||
# @return [Mab::Mixin::Tag] a form select input tag
|
||
def _form_select_nested(name, opts, html_options={})
|
||
html_class = html_options.delete(:class)
|
||
if opts.blank?
|
||
html_options.merge!(name: name, id: name, disabled: true,
|
||
class: "form-control")
|
||
select(html_options) do
|
||
option "None found", value: "none", selected: true
|
||
end
|
||
else
|
||
html_options.merge!(name: name, id: name,
|
||
class: "form-control #{html_class}")
|
||
select(html_options) do
|
||
opts.keys.sort.each do |key|
|
||
optgroup label: key do
|
||
opts[key].sort_by { |o| o.last }.each do |opt_val, opt_str|
|
||
if @input[name] == opt_val
|
||
option(opt_str, { value: opt_val, selected: true })
|
||
else
|
||
option(opt_str, { value: opt_val })
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
# Partial view that shows time entries. If a customer is given,
|
||
# only time entries of that customer are shown, and if also a task is
|
||
# given, then only the time entries of that task are shown.
|
||
#
|
||
# @param [Customer, nil] customer an customer to show time entries for
|
||
# @param [Customer, nil] task a task to show time entries for
|
||
# @return [Mab::Mixin::Tag] the main menu
|
||
def _time_entries(customer=nil, task=nil)
|
||
date_time_new = date_time_new_entry(@time_entries.first)
|
||
form.form_inline action: R(Timeline), method: :post do
|
||
table.table.table_condensed.table_striped.table_hover do
|
||
thead do
|
||
tr do
|
||
if customer.blank?
|
||
th.col_md_2.hidden_xs "Customer"
|
||
end
|
||
if task.blank?
|
||
th.col_md_2.col_xs_2 "Project/Task"
|
||
end
|
||
th.col_md_2.col_xs_2 "Date"
|
||
th.col_md_1.hidden_xs "Start"
|
||
th.col_md_1.hidden_xs "End"
|
||
th.col_md_2.col_xs_3 "Comment"
|
||
th.col_md_1.col_xs_2 "Total"
|
||
th.col_md_1.col_xs_1 "Bill?"
|
||
th.col_md_1.col_xs_2 {}
|
||
end
|
||
end
|
||
tbody do
|
||
tr.hidden_xs do
|
||
if task.present?
|
||
input type: :hidden, name: "task", value: task.id
|
||
else
|
||
if customer.blank?
|
||
td.col_md_1.hidden_xs { }
|
||
end
|
||
td.col_md_2 do
|
||
_form_select_nested("task", @task_list)
|
||
end
|
||
end
|
||
td.col_md_1 do
|
||
input.form_control type: :text, name: "date",
|
||
value: date_time_new && date_time_new.to_date.to_formatted_s
|
||
end
|
||
td.col_md_1 do
|
||
input.form_control type: :text, name: "start",
|
||
value: date_time_new && date_time_new.to_formatted_s(:time_only)
|
||
end
|
||
td.col_md_1 do
|
||
input.form_control type: :text, name: "end"
|
||
end
|
||
td.col_md_2 do
|
||
input.form_control type: :text, name: "comment"
|
||
end
|
||
td.col_md_1 do
|
||
p.form_control_static "N/A"
|
||
end
|
||
td.col_md_1 do
|
||
label.checkbox {_form_input_checkbox("bill") }
|
||
end
|
||
td.col_md_1 do
|
||
button.btn.btn_primary.btn_sm "Enter", type: :submit,
|
||
name: "enter", value: "Enter"
|
||
end
|
||
end
|
||
end
|
||
@time_entries.each do |entry|
|
||
tr(class: entry.task.billed? ? "billed" : nil) do
|
||
if customer.blank?
|
||
td.col_md_1.hidden_xs do
|
||
a entry.customer.shortest_name,
|
||
title: entry.customer.shortest_name,
|
||
href: R(CustomersN, entry.customer.id)
|
||
end
|
||
end
|
||
if task.blank?
|
||
td.col_md_2 do
|
||
a entry.task.name,
|
||
title: entry.task.name,
|
||
href: R(CustomersNTasksN, entry.customer.id, entry.task.id)
|
||
end
|
||
end
|
||
td.col_md_1 { entry.date.to_date }
|
||
td.col_md_1.hidden_xs { entry.start.to_formatted_s(:time_only) }
|
||
td.col_md_1.hidden_xs { entry.end.to_formatted_s(:time_only)}
|
||
if entry.comment.present?
|
||
td.col_md_2 do
|
||
a entry.comment, href: R(TimelineN, entry.id),
|
||
title: entry.comment
|
||
end
|
||
else
|
||
td.col_md_2 { a(href: R(TimelineN, entry.id)) { em "None" } }
|
||
end
|
||
td.col_md_1 { "%.2fh" % entry.hours_total }
|
||
td.col_md_1 do
|
||
_icon("ok") if entry.bill?
|
||
end
|
||
td.col_md_1 do
|
||
form.form_inline action: R(TimelineN, entry.id),
|
||
method: :post do
|
||
button.btn.btn_xs.btn_danger "Delete", type: :submit,
|
||
name: "delete", value: "Delete"
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
end # module StopTime::Views
|