version 1.3, 2011/03/21 04:19:25 |
version 1.46, 2012/01/27 04:13:45 |
|
|
#!/usr/bin/perl |
#!/usr/bin/perl |
|
# $AFresh1: rt_invoices.pl,v 1.45 2011/12/31 02:14:32 andrew Exp $ |
|
######################################################################## |
|
# Copyright (c) 2011 Andrew Fresh <andrew@afresh1.com> |
|
# |
|
# Permission to use, copy, modify, and distribute this software for any |
|
# purpose with or without fee is hereby granted, provided that the above |
|
# copyright notice and this permission notice appear in all copies. |
|
# |
|
# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES |
|
# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
|
# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR |
|
# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
|
# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN |
|
# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF |
|
# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
|
######################################################################## |
use strict; |
use strict; |
use warnings; |
use warnings; |
|
|
use 5.010; |
use 5.010; |
|
|
use YAML::Any; |
|
use Template; |
use Template; |
use RT::Client::REST; |
use RT::Client::REST; |
use RT::Client::REST::Ticket; |
use RT::Client::REST::Ticket; |
use RT::Client::REST::User; |
use RT::Client::REST::User; |
|
|
|
use File::Path; |
use DateTime; |
use DateTime; |
|
|
|
use lib './lib'; # XXX This is fragile, there are better ways |
|
use RTI::Config; |
|
use RTI::State; |
|
use RTI::Util qw/ round ymd_to_DateTime /; |
|
|
my $config = RTI::Config->new(); |
my $config = RTI::Config->new(); |
|
my $state = RTI::State->new( $config->get('state') ); |
|
|
#print Dump $config; exit; |
|
|
|
my $invoiceid = 1; # $state->{lastinvoice} + 1; |
|
|
|
my $startdate; |
|
my @invoices; |
|
foreach my $cust ( @{ $config->get('customers') } ) { |
|
|
|
# my $state = RTI::State->new($cust); |
|
# $invoice{state} = $state; |
|
my $lastinvdate; # = $state->{lastinvoicedte}; XXX Needs to be a DateTime |
|
#$lastinvdate = DateTime->now->subtract( months => 2 ) |
|
# ->set( hour => 0, minute => 0, second => 0 ); |
|
|
|
my %invoice = ( |
|
from => $config->get('from'), |
|
info => $config->get('info'), |
|
to => $cust->{address}, |
|
rates => $cust->{rates}, |
|
match => $cust->{match}, |
|
); |
|
|
|
if ( $cust->{base_rate} ) { |
|
my $day = $cust->{day} || 1; |
|
my $freq = $cust->{frequency} || 1; |
|
|
|
my $day_method; |
|
my $per; |
|
given ( $cust->{per} ) { |
|
when ('week') { $per = 'weeks'; $day_method = 'dow' } |
|
when ('month') { $per = 'months'; $day_method = 'day' } |
|
default { die "Unknown per [$cust->{per}]\n" } |
|
} |
|
|
|
my $lastbill |
|
= DateTime->now->set( hour => 0, minute => 0, second => 0 ); |
|
while ( $lastbill->$day_method != $day ) { |
|
$lastbill->subtract( days => 1 ); |
|
} |
|
|
|
my $date |
|
= $lastinvdate |
|
? $lastinvdate->clone->add( days => 1 ) |
|
: $lastbill->clone->subtract( $per => $freq ); |
|
|
|
my $title |
|
= $freq == 1 |
|
? ucfirst( $cust->{per} . 'ly' ) |
|
: $freq . ' ' . ucfirst( $cust->{per} ); |
|
$title .= ' Retainer'; |
|
|
|
my %project = ( title => $title, fees => [], ); |
|
|
|
while ( $date < $lastbill ) { |
|
my $start = $date->clone; |
|
|
|
$date->add( $per => $freq ); |
|
$date = $lastbill->clone if $date > $lastbill; |
|
if ( my $diff = $date->$day_method - $day ) { |
|
$date->subtract( days => $diff ); |
|
} |
|
|
|
my $end = $date->clone; |
|
|
|
$end->subtract( seconds => 1 ); |
|
|
|
$startdate = $start->clone if $startdate > $start; |
|
$invoice{start} ||= $start->clone; |
|
$invoice{end} = $end->clone; |
|
my %hours = ( |
|
start => $start->clone, |
|
end => $end->clone, |
|
hours => { %{ $cust->{hours} } }, |
|
); |
|
|
|
push @{ $invoice{hours} }, \%hours; |
|
push @{ $project{fees} }, |
|
{ |
|
count => 1, |
|
rate => $cust->{base_rate}, |
|
contents => $start->ymd . ' to ' . $end->ymd, |
|
}; |
|
|
|
} |
|
|
|
if ( @{ $project{fees} } ) { |
|
push @{ $invoice{projects} }, \%project; |
|
} |
|
} |
|
else { |
|
$invoice{end} = DateTime->now; |
|
push @{ $invoice{hours} }, |
|
{ end => DateTime->now, hours => $cust->{hours} }; |
|
} |
|
|
|
next unless $invoice{end}; |
|
push @invoices, \%invoice; |
|
} |
|
|
|
#print Dump \@invoices; exit; |
|
|
|
my $rt_conf = $config->get('rt'); |
my $rt_conf = $config->get('rt'); |
my $rt = RT::Client::REST->new( |
my $rt = RT::Client::REST->new( |
server => $rt_conf->{server}, |
server => $rt_conf->{server}, |
timeout => $rt_conf->{timeout}, |
timeout => $rt_conf->{timeout}, |
); |
); |
$rt->login( |
|
username => $rt_conf->{user}, |
|
password => $rt_conf->{pass}, |
|
); |
|
my $tickets = RT::Client::REST::Ticket->new( rt => $rt ); |
my $tickets = RT::Client::REST::Ticket->new( rt => $rt ); |
my $users = RT::Client::REST::User->new( rt => $rt ); |
|
|
|
|
$rt->login( username => $rt_conf->{user}, password => $rt_conf->{pass} ); |
|
|
|
#use YAML; |
|
#print Dump $config, $state; exit; |
|
|
|
my $customers = $config->get('customers'); |
|
my $startdate = set_dates($customers); |
|
|
my @limits = map +{ |
my @limits = map +{ |
attribute => 'status', |
attribute => 'status', |
operator => '=', |
operator => '=', |
|
|
# XXX This should be a config option |
# XXX This should be a config option |
qw/ open stalled resolved /; |
qw/ open stalled resolved /; |
|
|
#push @limits, |
push @limits, |
# { |
{ |
# attribute => 'resolved', |
attribute => 'last_updated', |
# operator => '>=', |
operator => '>=', |
# value => '2011-03-01' |
value => $startdate->ymd, |
# }; |
}; |
if ($startdate) { |
|
push @limits, |
|
{ |
|
attribute => 'last_updated', |
|
operator => '>=', |
|
value => $startdate->ymd, |
|
}; |
|
} |
|
|
|
#push @limits, { attribute => 'id', operator => '=', value => '51' }; |
|
#push @limits, { attribute => '', operator => '', value => '' }; |
|
|
|
my $results = $tickets->search( |
my $results = $tickets->search( |
limits => \@limits, |
limits => \@limits, |
orderby => 'id', |
orderby => 'id', |
); |
); |
|
|
#print Dump $ticket, $results; |
|
|
|
my $count = $results->count; |
my $count = $results->count; |
print "There are $count results that matched your query\n"; |
print "There are $count results that matched your query\n"; |
|
|
my $iterator = $results->get_iterator; |
my $iterator = $results->get_iterator; |
while ( my $ticket = &$iterator ) { |
while ( my $ticket = &$iterator ) { |
my %project = ( |
my $cust = find_customer_for_ticket( $ticket, $customers ); |
id => $ticket->id, |
if ( !$cust ) { |
queue => $ticket->queue, |
warn "No customer found for ticket " . $ticket->id; |
owner => $ticket->owner, |
next; |
title => $ticket->subject, |
} |
detail => 'Ticket: ' |
|
. $ticket->id |
|
. ' Queue: ' |
|
. $ticket->queue |
|
. ' Requestors: ' |
|
. join( ', ', $ticket->requestors ), |
|
fees => [], |
|
expenses => [], |
|
); |
|
|
|
my $invoice; |
next if $cust->{no_invoice}; |
INVOICE: foreach my $i (@invoices) { |
$cust->{invoice} ||= make_invoice($cust); |
next INVOICE unless $i->{match}; |
|
foreach my $m ( @{ $i->{match} } ) { |
|
my $type = $m->{type}; |
|
my $thing = join ' ', $ticket->$type; |
|
|
|
if ( $m->{$type} ) { |
die "$cust->{id} has no open invoices [" . $ticket->id . ']' |
my $match = lc $m->{$type}; |
unless $cust->{invoice}; |
next INVOICE unless lc($thing) ~~ $match; |
|
|
say 'Ticket ' . $ticket->id . " belongs to $cust->{id}"; |
|
|
|
my $project = make_project( $ticket, $cust ); |
|
next unless @{ $project->{fees} } || @{ $project->{expenses} }; |
|
|
|
foreach my $fee ( @{ $project->{fees} } ) { |
|
my $hours = hours_for_date( $cust->{invoice}, $fee->{date} ); |
|
|
|
my $type = 'unknown'; |
|
my $count = $fee->{count}; |
|
while ( $type && $count > 0 && $type ne 'default' ) { |
|
$type = exists $hours->{ $fee->{type} } |
|
&& $hours->{ $fee->{type} } > 0 ? $fee->{type} : 'default'; |
|
|
|
next unless exists $hours->{$type} && $hours->{$type} > 0; |
|
|
|
my $discount_time = 0; |
|
if ( $hours->{$type} > $count ) { |
|
$hours->{$type} -= $count; |
|
$discount_time = $count; |
} |
} |
elsif ( $m->{regex} ) { |
|
next INVOICE unless $thing ~~ /\Q$m->{regex}\E/; |
|
} |
|
else { |
else { |
warn "Invalid match!"; |
$discount_time = $hours->{$type}; |
next INVOICE; |
$hours->{$type} = 0; |
} |
} |
} |
|
$invoice = $i; |
|
} |
|
|
|
if ( !$invoice ) { |
if ($discount_time) { |
say "No invoice found for ticket " . $ticket->id; |
$cust->{invoice}->{discount}->{amount} |
|
+= round( $discount_time * $fee->{rate} ); |
|
$cust->{invoice}->{discount}->{hours}{$type} |
|
+= $discount_time; |
|
|
# XXX should construct a "new" invoice to pop onto the list |
$type = '' if $type eq 'default'; |
next; |
$count -= $discount_time; |
|
$fee->{detail} .= " $discount_time $type Hours Discounted"; |
|
} |
|
} |
} |
} |
|
|
#foreach my $r ($ticket->requestors) { |
push @{ $cust->{invoice}->{projects} }, $project; |
# $users->id( $r ); |
} |
# $users->retrieve; |
|
# print Dump $users; |
|
#} |
|
|
|
my $txns = $ticket->transactions( type => [qw(Comment Correspond)] ); |
|
my $txn_i = $txns->get_iterator; |
|
while ( my $txn = $txn_i->() ) { |
|
next unless $txn->time_taken; |
|
|
|
my ( $date, $time ) = split ' ', $txn->created; |
if ( my $unpaid_invoices = $state->unpaid_invoices() ) { |
my ( $year, $month, $day ) = split '-', $date; |
foreach my $custid ( keys %{$unpaid_invoices} ) { |
my ( $hour, $minute, $second ) = split ':', $time; |
my %project = ( title => 'Unpaid Invoices', fees => [], ); |
|
my $past_due = 0; |
|
my $unpaid = 0; |
|
|
my $txn_date = DateTime->new( |
my $cust; |
year => $year, |
foreach ( @{$customers} ) { |
month => $month, |
if ( $_->{id} eq $custid ) { |
day => $day, |
$cust = $_; |
hour => $hour, |
|
minute => $minute, |
|
second => $second, |
|
); |
|
|
|
next if $invoice->{start} && $invoice->{start} > $txn_date; |
|
next if $invoice->{end} < $txn_date; |
|
|
|
my $hours = {}; |
|
if ( $invoice->{hours} ) { |
|
foreach my $h ( @{ $invoice->{hours} } ) { |
|
next if $h->{start} && $h->{start} > $txn_date; |
|
next if $h->{end} < $txn_date; |
|
|
|
$hours = $h->{hours}; |
|
last; |
last; |
} |
} |
} |
} |
|
$cust ||= fake_customer($custid); |
|
|
my $work_time = sprintf "%.03f", $txn->time_taken / 60; |
foreach my $id ( |
my $work_type = $txn->cf('WorkType'); |
sort { $a <=> $b } |
my $work_rate |
keys %{ $unpaid_invoices->{$custid} } |
= $invoice->{rates}{$work_type} |
) |
|| $invoice->{rates}{default} |
{ |
|| 0; |
my $unpaid = $state->get_invoice($id); |
|
my $invdate = ymd_to_DateTime( $unpaid->{invdate} ); |
|
|
my $h_type |
my $content |
= exists $hours->{$work_type} |
= sprintf( "Invoice %06d from %s", $id, $invdate->ymd ); |
? $work_type |
if ( $cust->{duedate} |
: 'default'; |
&& DateTime->compare( $invdate, $cust->{duedate} ) > 0 ) |
|
{ |
|
$content = "PAST DUE: $content"; |
|
$past_due += $unpaid_invoices->{$custid}->{$id}; |
|
} |
|
else { |
|
$unpaid += $unpaid_invoices->{$custid}->{$id}; |
|
} |
|
|
my %fee = ( |
push @{ $project{fees} }, |
id => $txn->id, |
{ |
contents => $txn->created . ' (' |
id => $id, |
. $txn->id . ')' . "\n\n" |
contents => $content, |
. ( $txn->data || $ticket->subject ), |
count => 1, |
count => $work_time, |
rate => $unpaid_invoices->{$custid}->{$id}, |
rate => $work_rate, |
}; |
); |
|
if ( $work_type && $work_type ne 'Normal' ) { |
|
$fee{detail} = $work_type . ' rate'; |
|
} |
} |
|
|
push @{ $project{fees} }, \%fee; |
if ($past_due) { |
|
$cust->{invoice} ||= make_invoice(); |
|
|
next unless $hours->{$h_type} && $hours->{$h_type} > 0; |
$cust->{invoice}->{past_due} = $past_due; |
|
$cust->{invoice}->{unpaid} = $unpaid; |
|
$cust->{invoice}->{total_due} |
|
= $cust->{invoice}->{total} + $past_due + $unpaid; |
|
|
my $discount_time = 0; |
unshift @{ $cust->{invoice}->{projects} }, \%project; |
if ( $hours->{$h_type} > $work_time ) { |
|
$hours->{$h_type} -= $work_time; |
|
$discount_time = $work_time; |
|
} |
} |
else { |
|
$discount_time = $hours->{$h_type}; |
|
$hours->{$h_type} = 0; |
|
} |
|
|
|
if ($discount_time) { |
|
$fee{detail} = "$discount_time $work_type Hours Discounted"; |
|
$invoice->{discount}{amount} += $discount_time * $fee{rate}; |
|
$invoice->{discount}{hours}{$work_type} += $discount_time; |
|
} |
|
|
|
#print Dump $txn; exit; |
|
} |
} |
|
|
next unless @{ $project{fees} } || @{ $project{expenses} }; |
|
print " Added ticket $project{id}\n"; |
|
push @{ $invoice->{projects} }, \%project; |
|
} |
} |
|
|
foreach my $invoice (@invoices) { |
foreach my $cust ( @{$customers} ) { |
next unless $invoice->{projects} && @{ $invoice->{projects} }; |
my $invoice = $cust->{invoice}; |
|
next unless $invoice && $invoice->{projects} && @{ $invoice->{projects} }; |
|
|
|
$invoice->{custid} = $cust->{id}; |
|
$invoice->{transactions} = []; |
|
|
|
my %transactions; |
foreach my $project ( @{ $invoice->{projects} } ) { |
foreach my $project ( @{ $invoice->{projects} } ) { |
print "$project->{title}\n"; |
if ( $project->{transactions} ) { |
|
%transactions = ( %transactions, %{ $project->{transactions} } ); |
|
} |
my $subtotal = 0; |
my $subtotal = 0; |
foreach my $fee ( @{ $project->{fees} } ) { |
foreach my $fee ( @{ $project->{fees} } ) { |
my $amount = round( $fee->{count} * $fee->{rate} ); |
my $amount = round( $fee->{count} * $fee->{rate} ); |
print " $amount (" . ( $fee->{count} * $fee->{rate} ) . ")\n"; |
|
$subtotal += $amount; |
$subtotal += $amount; |
} |
} |
foreach my $expense ( @{ $project->{expenses} } ) { |
foreach my $expense ( @{ $project->{expenses} } ) { |
|
|
} |
} |
$project->{total} = $subtotal; |
$project->{total} = $subtotal; |
$invoice->{total} += $subtotal; |
$invoice->{total} += $subtotal; |
print " Subtotal $subtotal\n"; |
|
} |
} |
|
@{ $invoice->{transactions} } = sort { $a <=> $b } keys %transactions; |
|
|
if ( $invoice->{discount} ) { |
if ( $invoice->{discount} ) { |
my $c = "Included Hours\n"; |
my $c = "Included Hours\n"; |
if ( $invoice->{discount}{hours} ) { |
if ( $invoice->{discount}{hours} ) { |
foreach my $t ( keys %{ $invoice->{discount}{hours} } ) { |
foreach my $t ( keys %{ $invoice->{discount}{hours} } ) { |
$c .= "\n$invoice->{discount}{hours}{$t} $t hour"; |
my $type = $t eq 'default' ? '' : $t; |
|
$c .= "\n$invoice->{discount}{hours}{$t} $type hour"; |
$c .= 's' if $invoice->{discount}{hours}{$t} != 1; |
$c .= 's' if $invoice->{discount}{hours}{$t} != 1; |
$c .= "\n"; |
$c .= "\n"; |
} |
} |
|
|
$invoice->{total} -= round( $invoice->{discount}{amount} ); |
$invoice->{total} -= round( $invoice->{discount}{amount} ); |
} |
} |
|
|
if ( $invoice->{past_due} ) { |
next unless $invoice->{total} > 0 || $invoice->{total_due}; |
$invoice->{total_due} = $invoice->{total} + $invoice->{past_due}; |
|
} |
|
|
|
foreach my $key (qw/ start end /) { |
$invoice->{info} = $config->get('info'); |
if ( exists $invoice->{$key} ) { |
my $from = $config->get('from'); |
$invoice->{$key} = $invoice->{$key}->strftime('%B %d, %Y'); |
$from = get_user($from) if !ref $from; |
|
|
|
$invoice->{id} = $state->next_invoice_id; |
|
$invoice->{file} = sprintf 'invoice_%06d.pdf', $invoice->{id}; |
|
|
|
$invoice->{organization} = $from->{organization} || $from->{name}; |
|
$invoice->{from} = make_address($from); |
|
$invoice->{to} = make_address( $cust->{address} || $cust->{id} ); |
|
$invoice->{logo} = $config->get('logo'); |
|
|
|
$state->add_invoice($invoice); |
|
|
|
my $invoice_dir = $config->get('invoice_dir'); |
|
File::Path::make_path($invoice_dir); |
|
my $file = join '/', $invoice_dir, $invoice->{file}; |
|
|
|
my $tt = Template->new( INCLUDE_PATH => $config->get('template_dir'), ) |
|
|| die $Template::ERROR, "\n"; |
|
|
|
$tt->process( $config->get('invoice_template'), $invoice, $file ) |
|
or die $tt->error . "\n"; |
|
|
|
printf "Generated %s for %s: \$%.02f\n", $invoice->{file}, $cust->{id}, |
|
$invoice->{total}; |
|
|
|
} |
|
|
|
$state->save; |
|
|
|
sub find_customer_for_ticket { |
|
my ( $ticket, $customers ) = @_; |
|
|
|
foreach my $cust ( @{$customers} ) { |
|
next unless $cust->{match}; |
|
foreach my $m ( @{ $cust->{match} } ) { |
|
my $type = $m->{type}; |
|
my $match |
|
= exists $m->{$type} |
|
? lc( $m->{$type} ) |
|
: qr/\Q$m->{regex}\E/; |
|
my $thing = [ map {lc} $ticket->$type ]; |
|
|
|
if ( !$match ) { |
|
warn "Invalid match!"; |
|
next; |
|
} |
|
return $cust if ( $match ~~ $thing ); |
} |
} |
} |
} |
|
|
$invoice->{id} = $invoiceid; |
return fake_customer($ticket->requestors); |
$invoice->{file} = 'invoice_' . $invoiceid . '.pdf'; |
} |
|
|
print "Created Invoice\n"; |
sub fake_customer { |
print Dump $invoice; |
my ($custid) = @_; |
|
return unless $custid; |
|
|
my $tt = Template->new; |
my $cust = $config->new_customer; |
$tt->process( 'invoice.tex.tt', $invoice, $invoice->{file} ) |
push @{$customers}, $cust; |
or die $tt->error . "\n"; |
|
|
|
print "Generated $invoice->{file}\n"; |
$cust->{id} = $custid; |
|
$cust->{match} = [ |
|
{ type => 'requestors', |
|
regex => $cust->{id}, |
|
} |
|
]; |
|
|
$invoiceid++; |
set_cust_dates($cust); |
|
return $cust; |
} |
} |
|
|
# XXX Save State |
sub get_user { |
|
my ($id) = @_; |
|
|
sub round { |
state %users; |
my ($amount) = @_; |
return $users{$id} if $users{$id}; |
|
|
#$amount =~ s/\.\d\d\K.*$//; |
my %map = ( |
#return $amount; |
address_one => 'addr1', |
return sprintf "%.02f", $amount; |
address_two => 'addr2', |
|
email_address => 'email', |
|
real_name => 'name', |
|
name => 'username', |
|
); |
|
|
|
my $users = RT::Client::REST::User->new( rt => $rt, id => $id ); |
|
$users->retrieve; |
|
|
|
my %user; |
|
foreach my $m ( keys %{ $users->_attributes } ) { |
|
next unless $users->can($m); |
|
|
|
my $v = $users->$m; |
|
next unless $v; |
|
|
|
$m = $map{$m} if exists $map{$m}; |
|
|
|
$user{$m} = $v; |
|
} |
|
|
|
$users{$id} = \%user; |
|
return \%user; |
} |
} |
|
|
package RTI::Config; |
sub make_invoice { |
use strict; |
my ($cust) = @_; |
use warnings; |
|
|
|
use 5.010; |
my %invoice |
|
= ( end => $cust->{billend}->clone->subtract( seconds => 1 ) ); |
|
$invoice{start} = $cust->{startinvoicedate}->clone |
|
if $cust->{startinvoicedate}; |
|
|
use YAML::Any qw/ LoadFile /; |
if ( $cust->{base_rate} ) { |
|
my ( $project, $hours ) = make_base_project($cust); |
|
|
sub new { |
if ( @{ $project->{fees} } ) { |
my ( $class, $args ) = @_; |
$invoice{end} = $project->{end}; |
|
$invoice{hours} = $hours; |
|
push @{ $invoice{projects} }, $project; |
|
} |
|
} |
|
elsif ( $cust->{hours} ) { |
|
$invoice{hours} = [ |
|
{ end => $invoice{end}->clone, |
|
hours => $cust->{hours}, |
|
} |
|
]; |
|
} |
|
|
my $self = { file => '', }; |
return \%invoice; |
bless $self, $class; |
} |
my $file = $args->{file} || $self->_find_config; |
|
$self->read_config($file); |
|
|
|
return $self; |
sub make_base_project { |
|
my ($cust) = @_; |
|
|
|
my $date = $cust->{billstart}->clone; |
|
my $billend = $cust->{billend}->clone; |
|
my ($freq) = get_billing_frequency($cust); |
|
|
|
my $title |
|
= $cust->{frequency} == 1 |
|
? ucfirst( $cust->{per} . 'ly' ) |
|
: $freq . ' ' . ucfirst( $cust->{per} ); |
|
$title .= ' Retainer'; |
|
|
|
my %project = ( title => $title, start => $date->clone, fees => [], ); |
|
my @hours; |
|
|
|
while ( $date < $billend ) { |
|
my $start = $date->clone; |
|
|
|
$date->add($freq); |
|
|
|
my $end = $date > $billend ? $billend->clone : $date->clone; |
|
$end->subtract( seconds => 1 ); |
|
|
|
$project{end} = $end->clone; |
|
|
|
push @{ $project{fees} }, |
|
{ |
|
count => 1, |
|
rate => $cust->{base_rate}, |
|
contents => $start->ymd . ' to ' . $end->ymd, |
|
}; |
|
|
|
push @hours, |
|
{ |
|
start => $start->clone, |
|
end => $end->clone, |
|
hours => { %{ $cust->{hours} } }, |
|
}; |
|
} |
|
|
|
return \%project, \@hours; |
} |
} |
|
|
sub _find_config { |
sub make_address { |
my ($self) = @_; |
my ($addr) = @_; |
|
my @adr; |
|
|
# XXX This needs to be better |
$addr = get_user($addr) unless ref $addr; |
foreach my $file (qw/ rt_invoice.conf rt_invoice.cfg .rt_invoicerc /) { |
|
foreach my $dir ( '.', $ENV{HOME} . '/.rt_invoice', $ENV{HOME} ) { |
if ( $addr->{organization} ) { |
my $path = join '/', $dir, $file; |
push @adr, $addr->{organization}; |
return $path if -e $path; |
} |
|
elsif ( $addr->{name} && !$addr->{attn} ) { |
|
push @adr, $addr->{name}; |
|
} |
|
|
|
if ( ( $addr->{addr1} || $addr->{addr2} ) |
|
&& $addr->{city} |
|
&& $addr->{state} |
|
&& $addr->{zip} ) |
|
{ |
|
push @adr, $addr->{attn} if $addr->{attn}; |
|
push @adr, $addr->{addr1} if $addr->{addr1}; |
|
push @adr, $addr->{addr2} if $addr->{addr2}; |
|
push @adr, |
|
$addr->{city} . ', ' . $addr->{state} . ' ' . $addr->{zip}; |
|
} |
|
else { |
|
push @adr, $addr->{email} if $addr->{email}; |
|
} |
|
|
|
return join "\n\n", @adr; |
|
} |
|
|
|
sub make_project { |
|
my ( $ticket, $cust ) = @_; |
|
|
|
my %project = ( |
|
id => $ticket->id, |
|
queue => $ticket->queue, |
|
owner => $ticket->owner, |
|
title => $ticket->subject, |
|
detail => 'Ticket: ' |
|
. $ticket->id |
|
. ' Status: ' |
|
. $ticket->status |
|
. ' Requestors: ' |
|
. join( ', ', $ticket->requestors ), |
|
fees => [], |
|
expenses => [], |
|
); |
|
|
|
my $txns = $ticket->transactions( type => [qw(Comment Correspond)] ); |
|
my $txn_i = $txns->get_iterator; |
|
while ( my $txn = $txn_i->() ) { |
|
next if $state->txn_is_invoiced( $txn->id ); |
|
|
|
if ( my $expense = make_expense( $txn, $ticket ) ) { |
|
push @{ $project{expenses} }, $expense; |
|
$project{transactions}{ $txn->id } = 1; |
} |
} |
|
|
|
next unless $txn->time_taken; |
|
|
|
my $fee = make_fee( $txn, $cust->{rates}, $ticket ); |
|
|
|
if ( !( $fee->{rate} && $fee->{count} ) ) { |
|
warn "Invalid Fee, no rate or count"; |
|
next; |
|
} |
|
|
|
my $invoice = $cust->{invoice}; |
|
if ( $invoice->{start} && $invoice->{start} > $fee->{date} ) { |
|
warn "Ticket " |
|
. $ticket->id |
|
. " has uninvoiced Transaction " |
|
. $txn->id . "\n"; |
|
next; |
|
} |
|
next if $invoice->{end} < $fee->{date}; |
|
|
|
push @{ $project{fees} }, $fee; |
|
$project{transactions}{ $txn->id } = 1; |
} |
} |
return; |
|
|
return \%project; |
} |
} |
|
|
sub read_config { |
sub make_fee { |
my ( $self, $file ) = @_; |
my ( $txn, $rates, $ticket ) = @_; |
|
|
$file ||= $self->{file}; |
# XXX Only need $ticket for the alternate subject |
die "$file: no such file\n" unless -e $file; |
|
|
|
my $c = LoadFile($file) or die "Unable to load $file\n"; |
my $work_time = sprintf "%.03f", $txn->time_taken / 60; |
|
my $work_type = $txn->cf('WorkType'); |
|
|
$c->{customers} ||= []; |
if ( $work_type =~ s/\s*Onsite//i ) { |
if ( $c->{default} ) { |
|
foreach my $cust ( @{ $c->{customers} } ) { |
# XXX Do something special for onsite activities |
foreach my $k ( keys %{ $c->{default} } ) { |
} |
$cust->{$k} //= $c->{default}->{$k}; |
|
} |
$work_type =~ s/^\s+|\s+$//g; |
|
$work_type ||= 'Normal'; |
|
|
|
my %fee = ( |
|
id => $txn->id, |
|
contents => $txn->created . ' (' |
|
. $txn->id . ')' . "\n\n" |
|
. ( $txn->data || $ticket->subject ), |
|
count => $work_time, |
|
type => $work_type, |
|
date => ymd_to_DateTime( $txn->created ), |
|
rate => $rates->{$work_type} || $rates->{default} || 0, |
|
); |
|
|
|
if ( $work_type && $work_type ne 'Normal' ) { |
|
$fee{detail} = $work_type . ' rate'; |
|
} |
|
|
|
return \%fee; |
|
} |
|
|
|
sub make_expense { |
|
my ( $txn, $ticket ) = @_; |
|
|
|
my $amount = $txn->cf('ExpenseAmount') or return; |
|
|
|
my %expense = ( |
|
id => $txn->id, |
|
contents => $txn->created . ' (' |
|
. $txn->id . ')' . "\n\n" |
|
. ( $txn->data || $ticket->subject ), |
|
amount => $amount, |
|
date => ymd_to_DateTime( $txn->created ), |
|
|
|
# detail => ???, |
|
); |
|
|
|
return \%expense; |
|
} |
|
|
|
sub hours_for_date { |
|
my ( $invoice, $date ) = @_; |
|
|
|
my $hours = {}; |
|
if ( $invoice->{hours} ) { |
|
foreach my $h ( @{ $invoice->{hours} } ) { |
|
next if $h->{start} && $h->{start} > $date; |
|
next if $h->{end} < $date; |
|
|
|
$hours = $h->{hours}; |
|
last; |
} |
} |
} |
} |
|
return $hours; |
|
} |
|
|
$self->{_config} = $c; |
sub get_billing_frequency { |
$self->{file} = $file; |
my ($cust) = @_; |
|
my $per = $cust->{per} || 'week'; |
|
my $freq = $cust->{frequency} || 1; |
|
|
|
my $day_method; |
|
given ($per) { |
|
when ('week') { $per = 'weeks'; $day_method = 'dow' } |
|
when ('month') { $per = 'months'; $day_method = 'day' } |
|
default { die "Unknown per [$per]\n" } |
|
} |
|
|
|
return DateTime::Duration->new( $per => $freq ), $day_method; |
} |
} |
|
|
sub get { |
sub set_dates { |
my ( $self, $key ) = @_; |
my ($customers) = @_; |
|
|
# XXX This should deep copy? not a reference would be good |
my $newest_invoice; |
return $self->{_config}->{$key}; |
my $max_duration; |
|
|
|
foreach my $cust ( @{$customers} ) { |
|
set_cust_dates($cust); |
|
|
|
my ($freq) = get_billing_frequency($cust); |
|
$max_duration = $freq |
|
if !$max_duration |
|
|| DateTime::Duration->compare( $freq, $max_duration ) > 0; |
|
|
|
if ( $cust->{startinvoicedate} ) { |
|
my $date = $cust->{startinvoicedate}->clone; |
|
$newest_invoice = $date->clone |
|
if !$newest_invoice || $newest_invoice < $date; |
|
} |
|
} |
|
|
|
return $newest_invoice->clone->subtract($max_duration) |
|
->subtract( days => 1 ); |
} |
} |
|
|
package RTI::State; |
sub set_cust_dates { |
use strict; |
my ($cust) = @_; |
use warnings; |
|
|
|
use 5.010; |
my $day = $cust->{day} || 0; |
|
my ( $freq, $day_method ) = get_billing_frequency($cust); |
|
|
use YAML::Any qw/ LoadFile DumpFile /; |
my $end = DateTime->now( time_zone => 'local' ) |
|
->set( hour => 0, minute => 0, second => 0 ); |
|
|
sub new { |
my $start = $end->clone->subtract($freq); |
my ( $class, $args ) = @_; |
|
|
|
my $self = { file => '', }; |
# XXX This is helpful, but monthly and billday > 28 == !!! |
bless $self, $class; |
$end->subtract( days => 1 ) while $day && $end->$day_method != $day; |
my $file = $args->{file} || $self->_find_config; |
|
$self->read_config($file); |
|
|
|
return $self; |
my $lastinvoice = $state->last_invoice( $cust->{id} ); |
|
if ( $lastinvoice && $lastinvoice->{end} ) { |
|
$start = ymd_to_DateTime( $lastinvoice->{end} )->add( days => 1 ); |
|
$cust->{startinvoicedate} = $start->clone; |
|
} |
|
|
|
$cust->{duedate} |
|
= $cust->{net} |
|
? DateTime->now->subtract( days => $cust->{net} ) |
|
: 0; |
|
|
|
$cust->{no_invoice} = 1 if $start->clone->add($freq) > $end; |
|
$cust->{billend} = $end; |
|
$cust->{billstart} = $start; |
} |
} |