RT/Invoicing/rt_invoices.pl - diff

Return to rt_invoices.pl CVS log

Up to [local] / RT / Invoicing

Diff for /RT/Invoicing/rt_invoices.pl between version 1.39 and 1.40

version 1.39, 2011/12/21 02:21:54

version 1.40, 2011/12/22 04:52:28

Line 28

use File::Path;

use DateTime;

use lib './lib'; # XXX This is fragile, there are better ways

use RTI::Config;

use RTI::State;

my $config = RTI::Config->new();

my $state = RTI::State->new( $config->get('state') );

Line 43

Line 47

#use YAML;

#print Dump $config, $state; exit;

my $startdate;

my $customers = $config->get('customers');

my $startdate = set_dates($customers);

my @limits = map +{

attribute => 'status',

Line 57

Line 61

# XXX This should be a config option

qw/ open stalled resolved /;

if ($startdate) {

push @limits,

{

attribute => 'last_updated',

operator => '>=',

value => $startdate->ymd,

};

}

my $results = $tickets->search(

limits => \@limits,

Line 76

Line 78

my $iterator = $results->get_iterator;

while ( my $ticket = &$iterator ) {

my $cust = find_customer_for_ticket($ticket);

my $cust = find_customer_for_ticket($ticket, $customers);

if ( !$cust ) {

warn "No customer found for ticket " . $ticket->id;

next;

}

say 'Ticket ' . $ticket->id . " belongs to $cust->{id}";

next if $cust->{no_invoices};

$cust->{invoice} ||= make_invoice($cust);

if ( !$cust->{invoice}->{end} ) {

if ( !$cust->{invoice} ) {

say " $cust->{id} has no open invoices [" . $ticket->id . ']';

$cust->{no_invoices} = 1;

say "$cust->{id} has no open invoices [" . $ticket->id . ']';

next;

}

say 'Ticket ' . $ticket->id . " belongs to $cust->{id}";

my $project = make_project( $ticket, $cust );

next unless @{ $project->{fees} } || @{ $project->{expenses} };

Line 130

Line 134

push @{ $cust->{invoice}->{projects} }, $project;

}

foreach my $cust ( @{$customers} ) {

my $invoice = $cust->{invoice};

next unless $invoice && $invoice->{projects} && @{ $invoice->{projects} };

my %li = (

$invoice->{custid} = $cust->{id};

custid => $cust->{id},

$invoice->{transactions} = [];

invdate => DateTime->now( time_zone => 'local' )->ymd,

transactions => [],

);

my %transactions;

foreach my $project ( @{ $invoice->{projects} } ) {

Line 156

Line 158

$project->{total} = $subtotal;

$invoice->{total} += $subtotal;

}

@{ $li{transactions} } = sort { $a <=> $b } keys %transactions;

@{ $invoice->{transactions} } = sort { $a <=> $b } keys %transactions;

if ( $invoice->{discount} ) {

my $c = "Included Hours\n";

Line 172

Line 174

$invoice->{total} -= round( $invoice->{discount}{amount} );

}

$invoice->{past_due} = 0;

if (my $unpaid_invoices = $state->unpaid_invoices($cust->{id})) {

my %project = ( title => 'Unpaid Invoices', fees => [], );

foreach my $id ( sort { $a <=> $b } keys %{$unpaid_invoices} ) {

my $unpaid = $state->get_invoice($id);

$invoice->{past_due} += $unpaid_invoices->{$id};

push @{ $project{fees} }, {

id => $id,

contents => sprintf(

"Invoice %06d from %s",

$id, ymd_to_DateTime( $unpaid->{invdate} )->ymd

count => 1,

rate => $unpaid_invoices->{$id},

};

}

unshift @{ $invoice->{projects} }, \%project;

}

if ( $invoice->{past_due} ) {

$invoice->{total_due} = $invoice->{total} + $invoice->{past_due};

}

Line 182

Line 204

my $from = $config->get('from');

$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} );

$state->{lastinvoice}++;

$invoice->{id} = $state->{lastinvoice};

$invoice->{file} = sprintf 'invoice_%06d.pdf', $state->{lastinvoice};

$invoice->{logo} = $config->get('logo');

foreach my $k (qw/ file transactions start end total past_due total_due /)

$state->add_invoice( $invoice );

{

my $v;

if ( $invoice->{$k} ) { $v = $invoice->{$k} }

elsif ( $cust->{$k} ) { $v = $cust->{$k} }

if ( defined $v && length $v ) {

if ( ref $v eq 'DateTime' ) {

$li{$k} = $v->ymd;

}

else {

$li{$k} = $v;

}

$state->{invoice}->{ $invoice->{id} } = \%li;

foreach my $key (qw/ start end /) {

if ( exists $invoice->{$key} ) {

Line 226

Line 233

printf "Generated %s for %s: \$%.02f\n", $invoice->{file}, $cust->{id},

$invoice->{total};

}

$state->save;

Line 239

Line 247

}

sub find_customer_for_ticket {

my ($ticket) = @_;

my ($ticket, $customers) = @_;

foreach my $cust ( @{$customers} ) {

next unless $cust->{match};

Line 260

Line 268

}

# Fake customer if we didn't find one

my $cust = $config->get('default') || {};

my $cust = $config->new_customer;

( $cust->{id} ) = $ticket->requestors;

return unless $cust->{id};

Line 272

Line 280

}

];

set_cust_dates($cust);

return $cust;

}

Line 311

Line 320

sub make_invoice {

my ($cust) = @_;

my $day = $cust->{day} ||= 0;

return unless $cust->{billstart};

my $per = $cust->{per} ||= 'week';

my $freq = $cust->{frequency} ||= 1;

my $day_method;

my ($freq) = get_billing_frequency($cust);

given ($per) {

return if $cust->{billstart}->clone->add($freq) > $cust->{billend};

when ('week') { $per = 'weeks'; $day_method = 'dow' }

when ('month') { $per = 'months'; $day_method = 'day' }

default { die "Unknown per [$per]\n" }

}

my $billend = DateTime->now( time_zone => 'local' )

my %invoice = ( end => $cust->{billend}->clone->subtract( seconds => 1 ) );

->set( hour => 0, minute => 0, second => 0 );

$invoice{start} = $cust->{startinvoicedate}->clone

if $cust->{startinvoicedate};

# XXX This is helpful, but monthly and billday > 28 == !!!

return if $invoice{start} && $invoice{start} > $invoice{end};

$billend->subtract( days => 1 )

while $day && $billend->$day_method != $day;

my $date = $billend->clone->subtract( $per => $freq );

my %invoice = ( end => $billend->clone->subtract( seconds => 1 ) );

my $lastinvoice = $state->last_invoice( $cust->{id} );

if ( $lastinvoice->{date} ) {

my $last_invoice_date = ymd_to_DateTime( $lastinvoice->{date} );

$date = $last_invoice_date->clone->add( days => 1 );

$invoice{start} = $date->clone;

$startdate = $date->clone->subtract( $per => $freq )

if !$startdate || $startdate > $date;

}

# Is the start date more than $freq $per before the end date?

return {}

if DateTime->compare( $date->clone->add( $per => $freq ), $billend )

> 0;

if ( $cust->{base_rate} ) {

my ( $project, $hours ) = make_base_project(

my ( $project, $hours ) = make_base_project( $cust );

$cust,

{ date => $date,

billend => $billend,

per => $per,

freq => $freq,

}

);

if ( @{ $project->{fees} } ) {

$invoice{end} = $project->{end};

Line 372

Line 348

];

}

return {} if $invoice{start} && $invoice{end} < $invoice{start};

return \%invoice;

}

sub make_base_project {

my ( $cust, $args ) = @_;

my ( $cust ) = @_;

my $date = $args->{date};

my $date = $cust->{billstart}->clone;

my $billend = $args->{billend};

my $billend = $cust->{billend}->clone;

my $per = $args->{per};

my ($freq) = get_billing_frequency($cust);

my $freq = $args->{freq};

my $title

= $freq == 1

= $cust->{frequency} == 1

? ucfirst( $cust->{per} . 'ly' )

: $freq . ' ' . ucfirst( $cust->{per} );

$title .= ' Retainer';

Line 397

Line 370

while ( $date < $billend ) {

my $start = $date->clone;

$date->add( $per => $freq );

$date->add( $freq );

my $end = $date->clone->subtract( seconds => 1 );

my $end = $date > $billend ? $billend->clone : $date->clone;

$end = $billend->clone->subtract( seconds => 1 ) if $date > $billend;

$end->subtract( seconds => 1 );

$project{end} = $end->clone;

Line 593

Line 566

);

}

package RTI::Config;

sub get_billing_frequency {

use strict;

my ($cust) = @_;

use warnings;

my $per = $cust->{per} || 'week';

my $freq = $cust->{frequency} || 1;

use 5.010;

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" }

}

use YAML::Any qw/ LoadFile Dump Load /;

return DateTime::Duration->new($per => $freq), $day_method;

use File::Spec;

sub new {

my ( $class, $args ) = @_;

my $self = { file => '', };

bless $self, $class;

my $file = $args->{file} || $self->_find_config;

$self->read_config($file);

return $self;

}

sub _find_config {

sub set_dates {

my ($self) = @_;

my ($customers) = @_;

my $newest_invoice;

my $max_duration;

# XXX This needs to be better

foreach my $cust ( @{$customers} ) {

foreach my $file (qw/ rt_invoice.conf rt_invoice.cfg .rt_invoicerc /) {

set_cust_dates($cust);

foreach my $dir ( '.', $ENV{HOME} . '/.rt_invoicing', $ENV{HOME} ) {

my $path = join '/', $dir, $file;

return $path if -e $path;

}

return;

}

sub read_config {

my ($freq) = get_billing_frequency($cust);

my ( $self, $file ) = @_;

$max_duration = $freq

if !$max_duration

|| DateTime::Duration->compare( $freq, $max_duration ) > 0;

$file ||= $self->{file};

if ( $cust->{startinvoicedate} ) {

die "$file: no such file\n" unless -e $file;

my $date = $cust->{startinvoicedate}->clone;

$newest_invoice = $date->clone

my $c = LoadFile($file) or die "Unable to load $file\n";

if !$newest_invoice || $newest_invoice < $date;

$c->{customers} ||= [];

if ( $c->{default} ) {

foreach my $cust ( @{ $c->{customers} } ) {

foreach my $k ( keys %{ $c->{default} } ) {

$cust->{$k} //= Load( Dump( $c->{default}->{$k} ) );

}

$self->{_config} = $c;

return $newest_invoice->clone->subtract($max_duration)

$self->{file} = $file;

->subtract( days => 1 );

}

sub get {

sub set_cust_dates {

my ( $self, $key ) = @_;

my ($cust) = @_;

my $value = Load( Dump( $self->{_config}->{$key} ) );

return $value if $value;

my $day = $cust->{day} || 0;

my ( $volume, $directories, $file )

my ( $freq, $day_method ) = get_billing_frequency($cust);

= File::Spec->splitpath( File::Spec->rel2abs( $self->{file} ) );

given ($key) {

my $billend = DateTime->now( time_zone => 'local' )

when ('state') {

->set( hour => 0, minute => 0, second => 0 );

$value = $self->{file};

$value =~ s/(?:\.[^.]+)?$/\.state/;

}

when ('invoice_dir') {

$value = File::Spec->catdir( $volume, $directories, 'invoices' );

}

when ('template_dir') {

$value = File::Spec->catdir( $volume, $directories );

}

when ('invoice_template') {

$value = 'invoice.tex.tt';

}

when ('logo') {

$value = File::Spec->catfile( $volume, $directories, 'Logo.pdf' );

}

return $value;

my $date = $billend->clone->subtract($freq);

}

package RTI::State;

# XXX This is helpful, but monthly and billday > 28 == !!!

use strict;

$billend->subtract( days => 1 )

use warnings;

while $day && $billend->$day_method != $day;

use 5.010;

$cust->{billend} = $billend;

use YAML::Any qw/ LoadFile DumpFile /;

my $lastinvoice = $state->last_invoice( $cust->{id} );

if ( $lastinvoice && $lastinvoice->{end} ) {

my $file = '';

$date = ymd_to_DateTime( $lastinvoice->{end} )->add( days => 1 );

$cust->{startinvoicedate} = $date->clone;

sub new {

my $class;

( $class, $file ) = @_;

my $self = { lastinvoice => 0, };

if ( -e $file ) {

$self = LoadFile($file) or die "Unable to load state: $!";

}

bless $self, $class;

$cust->{billstart} = $date;

die "Need to pass filename to new: $!" unless $file;

return $self;

}

sub last_invoice {

my ( $self, $custid ) = @_;

state %table;

if ( !%table ) {

foreach my $date ( sort keys %{ $self->{invoice} } ) {

while ( my ( $id, $inv ) = each %{ $self->{invoice}->{$date} } ) {

next unless $inv->{custid};

$table{ $inv->{custid} } = {

id => $id,

date => $date,

%{$inv},

};

}

return $table{$custid} || {};

}

sub txn_is_invoiced {

my ( $self, $txn ) = @_;

state %table;

if ( !%table ) {

foreach my $date ( sort keys %{ $self->{invoice} } ) {

foreach my $inv ( values %{ $self->{invoice}->{$date} } ) {

foreach my $t ( @{ $inv->{transactions} } ) {

$table{$t} = 1;

}

return $table{$txn};

}

sub save {

my ($self) = @_;

DumpFile( $file, {%$self} ) or die "Unable to save state: $!";

}

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>