GL.pm

# General ledger functions
# Copyright (C) 2009-2014, AllWorldIT
# Copyright (C) 2008, LinuxRulz
# Copyright (C) 2006-2007 Nigel Kukard  <nkukard@lbsd.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.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along
# with this program; if not, write to the Free Software Foundation, Inc.,
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.




package wiaflos::server::GL;

use strict;
use warnings;


use wiaflos::constants;
use wiaflos::server::dblayer;
use wiaflos::server::cache;

use Math::BigFloat;

# Exporter stuff
require Exporter;
our (@ISA,@EXPORT,@EXPORT_OK);
@ISA = qw(Exporter);
@EXPORT = qw(
	GL_TRANSTYPE_NORMAL
	GL_TRANSTYPE_YEAREND
	GL_TRANSTYPE_AUDIT
	GL_TRANSTYPE_AUDIT_YEAREND
);
@EXPORT_OK = ();


use constant {
	GL_TRANSTYPE_NORMAL	=>	1,
	GL_TRANSTYPE_YEAREND	=>	2,
	GL_TRANSTYPE_AUDIT	=>	4,
	GL_TRANSTYPE_AUDIT_YEAREND	=>	8
};


# Our current error message
my $error = "";

# Set current error message
# Args: error_message
sub setError
{
	my $err = shift;
	my ($package,$filename,$line) = caller;
	my (undef,undef,undef,$subroutine) = caller(1);

	# Set error
	$error = "$subroutine($line): $err";
}

# Return current error message
# Args: none
sub Error
{
	my $err = $error;

	# Reset error
	$error = "";

	# Return error
	return $err;
}


# Backend function to build account item hash
sub sanitizeRawGLAccountItem
{
	my $rawData = shift;


	my $item;
	$item->{'ID'} = $rawData->{'ID'};

	$item->{'Number'} = getGLAccountNumberFromID($rawData->{'ID'});

	$item->{'ParentGLAccountID'} = $rawData->{'ParentGLAccountID'};
	$item->{'Name'} = $rawData->{'Name'};
	$item->{'FinCatCode'} = $rawData->{'FinCatCode'};
	$item->{'FinCatDescription'} = $rawData->{'FinCatDescription'};
	$item->{'RwCatCode'} = $rawData->{'RwCatCode'};
	$item->{'RwCatDescription'} = $rawData->{'RwCatDescription'};

	return $item;
}



# Backend function to build GL transaction item hash
sub sanitizeRawGLTransactionItem
{
	my $rawData = shift;


	my $item;

	$item->{'ID'} = $rawData->{'ID'};
	$item->{'TransactionDate'} = $rawData->{'TransactionDate'};
	$item->{'Reference'} = $rawData->{'Reference'};
	$item->{'Type'} = $rawData->{'Type'};
	$item->{'Posted'} = $rawData->{'Posted'};

	return $item;
}



# Check if GL account ID exists
# Backend function, takes 1 parameter which is the GL account ID
sub GLAccountIDExists
{
	my $GLAccID = shift;


	# Select account count
	my $rows = DBSelectNumResults("FROM gl_accounts WHERE ID = ".DBQuote($GLAccID));
	if (!defined($rows)) {
		setError(wiaflos::server::dblayer::Error());
		return ERR_DB;
	}

	# Check we got a result
	if ($rows < 1) {
		setError("Error finding GL account '$GLAccID'");
		return ERR_NOTFOUND;
	}

	return 1;
}


# Check if a GL account code exists
sub GLAccountCodeExists
{
	my ($parentID,$code) = @_;
	my $extra_sql = "";


	# If we have a parent use it
	if (defined($parentID) && $parentID ne "") {
		$extra_sql .= " AND ParentGLAccountID = ".DBQuote($parentID);
	} else {
		$extra_sql .= " AND ParentGLAccountID IS NULL";
	}

	# Select account count
	my $rows = DBSelectNumResults("FROM gl_accounts WHERE Code = ".DBQuote($code)." $extra_sql");
	if (!defined($rows)) {
		setError(wiaflos::server::dblayer::Error());
		return ERR_DB;
	}

	return $rows > 0 ? 1 : 0;
}


# Check if transaction exists
# Backend function, takes 1 parameter which is the transaction ID
sub GLTransactionIDExists
{
	my $transActID = shift;


	# Select transaction count
	my $rows = DBSelectNumResults("FROM gl_transactions WHERE ID = ".DBQuote($transActID));
	if (!defined($rows)) {
		setError(wiaflos::server::dblayer::Error());
		return ERR_DB;
	}

	return $rows > 0 ? 1 : 0;
}


# Get GL account ID from GL account number
# Backend function, takes a GL account number and returns the GL account ID
sub getGLAccountIDFromNumber
{
	my $GLAccNumber = shift;


	# Check cache
	my ($cache_res,$cache) = cacheGetKeyPair('GL/Number-to-AccountID',$GLAccNumber);
	if ($cache_res != RES_OK) {
		setError(wiaflos::server::cache::Error());
		return $cache_res;
	}
	return $cache if (defined($cache));


	# Pull list of GL accounts
	my $sth = DBSelect("
		SELECT
			ID, Code
		FROM
			gl_accounts
	");
	if (!$sth) {
		setError(wiaflos::server::dblayer::Error());
		return ERR_DB;
	}

	# Fetch rows, while we not found anything
	my $GLAccID;
	while ((my $row = $sth->fetchrow_hashref()) && !defined($GLAccID)) {
		my $tmpGLAccNumber = getGLAccountNumberFromID($row->{'ID'});
		# If not defined b0rk out
		if (!defined($tmpGLAccNumber)) {
			DBFreeRes($sth);
			return ERR_UNKNOWN;
		}

		# Check if we found it
		if ($GLAccNumber eq $tmpGLAccNumber) {
			$GLAccID = $row->{'ID'};
		}
	}

	DBFreeRes($sth);

	if (!defined($GLAccID)) {
		setError("Error finding GL account '$GLAccNumber'");
		return ERR_NOTFOUND;
	}

	# Cache this
	$cache_res = cacheStoreKeyPair('GL/Number-to-AccountID',$GLAccNumber,$GLAccID);
	if ($cache_res != RES_OK) {
		setError(wiaflos::server::cache::Error());
		return $cache_res;
	}

	return $GLAccID;
}


# Return financial category ID from code
sub getGLFinCatIDFromCode
{
	my $finCatCode = shift;


	# Select financial category
	my $sth = DBSelect("
		SELECT
			ID
		FROM
			gl_financial_categories
		WHERE
			Code = ".DBQuote($finCatCode)."
	");
	if (!$sth) {
		setError(wiaflos::server::dblayer::Error());
		return ERR_DB;
	}

	my $row = $sth->fetchrow_hashref();
	DBFreeRes($sth);

	# Check we got a result
	if (!defined($row)) {
		setError("Error finding financial category '$finCatCode'");
		return ERR_NOTFOUND;
	}

	return $row->{'ID'};
}


# Return reporting category ID from code
sub getGLRwCatIDFromCode
{
	my $rwCatCode = shift;


	# Select reporting category
	my $sth = DBSelect("
		SELECT
			ID
		FROM
			gl_reportwriter_categories
		WHERE
			Code = ".DBQuote($rwCatCode)."
	");
	if (!$sth) {
		setError(wiaflos::server::dblayer::Error());
		return ERR_DB;
	}

	my $row = $sth->fetchrow_hashref();
	DBFreeRes($sth);

	# Check we got a result
	if (!defined($row)) {
		setError("Error finding reporting category '$rwCatCode'");
		return ERR_NOTFOUND;
	}

	return $row->{'ID'};
}


# Return report writer categories
sub getGLRwCats
{
	# Select reporting category
	my $sth = DBSelect("
		SELECT
			ID, Code, Description
		FROM
			gl_reportwriter_categories
	");
	if (!$sth) {
		setError(wiaflos::server::dblayer::Error());
		return ERR_DB;
	}

	# Fetch rows
	my @entries;
	while (my $row = $sth->fetchrow_hashref()) {
		my $entry;

		$entry->{'ID'} = $row->{'ID'};
		$entry->{'Code'} = $row->{'Code'};
		$entry->{'Description'} = $row->{'Description'};

		push(@entries,$entry);
	}

	DBFreeRes($sth);

	return \@entries;
}


# Resolve the full GL account reference
sub getGLAccountNumberFromID
{
	my $accID = shift;


	# Check cache
	my ($cache_res,$cache) = cacheGetKeyPair('GL/AccountID-to-Number',$accID);
	if ($cache_res != RES_OK) {
		setError(wiaflos::server::cache::Error());
		return $cache_res;
	}
	return $cache if (defined($cache));


	# Return account ref & parent
	my $sth = DBSelect("
		SELECT
			Code, ParentGLAccountID
		FROM
			gl_accounts
		WHERE
			ID = ".DBQuote($accID)."
	");
	if (!$sth) {
		setError(wiaflos::server::dblayer::Error());
		return undef;
	}

	# Grab row & free
	my $row = $sth->fetchrow_hashref();
	DBFreeRes($sth);

	# Get parent acc number ... or if we the parent, return our acc number
	my $accnum = "";
	# If we have parent, get its ref
	if (defined($row->{'ParentGLAccountID'})) {
		# Check return value
		if (my $ret = getGLAccountNumberFromID($row->{'ParentGLAccountID'})) {
			# And add ref to our ref
			$accnum = "$ret:".$row->{'Code'};
		} else {
			return undef;
		}
	} else {
		$accnum = $row->{'Code'};
	}

	# Cache this
	$cache_res = cacheStoreKeyPair('GL/AccountID-to-Number',$accID,$accnum);
	if ($cache_res != RES_OK) {
		setError(wiaflos::server::cache::Error());
		return $cache_res;
	}


	return $accnum;
}


# Check GL account financial category
# Returns:
#	1	- match
#	0	- no match
sub checkGLAccountFinCat
{
	my ($GLAccID,$finCatCode) = @_;


	# Check and return GL account financial category
	my $sth = DBSelect("
		SELECT
			gl_financial_categories.Code
		FROM
			gl_financial_categories, gl_accounts
		WHERE
			gl_accounts.ID = ".DBQuote($GLAccID)."
			AND gl_financial_categories.ID = gl_accounts.FinCatID
	");
	if (!$sth) {
		setError(wiaflos::server::dblayer::Error());
		return ERR_DB;
	}

	# Grab row
	my $row = $sth->fetchrow_hashref();
	DBFreeRes($sth);

	# Check we got a result
	if (!defined($row)) {
		setError("Error finding GL account '$GLAccID'");
		return ERR_NOTFOUND;
	}

	return $row->{'Code'} eq $finCatCode ? 1 : 0;
}



## @fn getGLAccountTree
# Resolve the set of accounts into a tree
#
# @returns Array ref of hash refs, @see getGLAccounts with the additional items...
# @li Children Array ref of hash refs, children of this account
# @li Level Depth level of this account
sub getGLAccountTree
{
	# Grab account list
	my $accounts = getGLAccounts();
	if (ref($accounts) ne "ARRAY") {
		return $accounts;
	}

	my %accountsByID;
	my @paccounts; # Parent accounts
	foreach my $account (@{$accounts}) {
		# Generate our rows by ID table
		$accountsByID{$account->{'ID'}} = $account;
		# Check if we're a parent account
		push(@paccounts,$account) if (!defined($account->{'ParentGLAccountID'}));
	}
	# Resolve children
	foreach my $account (@{$accounts}) {
		# Make sure we're a child and not a parent
		if (defined($account->{'ParentGLAccountID'})) {
			# This is the account parent
			my $parent = $accountsByID{$account->{'ParentGLAccountID'}};
			# Attach us as a child
			push(@{$parent->{'Children'}}, $account);
		}
	}
	# Resolve levels
	foreach my $parent (@paccounts) {
		# Resolve the account level
		sub resolveLevel {
			my ($raccount,$plevel) = @_;

			# We 1 level down
			$raccount->{'Level'} = $plevel + 1;
			# Loop with children
			foreach my $caccount (@{$raccount->{'Children'}}) {
				resolveLevel($caccount,$raccount->{'Level'});
			}
		}
		# Parents are level 0, so we set this to -1
		resolveLevel($parent,-1);
	}

	return \@paccounts;
}


# Return an array of general ledger accounts
sub getGLAccounts
{
	my @accounts = ();

	# Return list of GL accounts
	my $sth = DBSelect("
		SELECT
			gl_accounts.ID, gl_accounts.ParentGLAccountID, gl_accounts.Code, gl_accounts.Name,
			gl_financial_categories.Code AS FinCatCode, gl_financial_categories.Description AS FinCatDescription,
			gl_reportwriter_categories.Code AS RwCatCode, gl_reportwriter_categories.Description AS RwCatDescription
		FROM
			gl_accounts, gl_financial_categories, gl_reportwriter_categories
		WHERE
			gl_financial_categories.ID = gl_accounts.FinCatID
			AND gl_reportwriter_categories.ID = gl_accounts.RwCatID
	");
	if (!$sth) {
		setError(wiaflos::server::dblayer::Error());
		return ERR_DB;
	}

	# Fetch rows
	while (my $row = $sth->fetchrow_hashref()) {
		my $account = sanitizeRawGLAccountItem($row);

		push(@accounts,$account);
	}

	DBFreeRes($sth);

	return \@accounts;
}


# Return a hash containing account details
# Parameters:
#		AccountID		- GL account ID
#		AccountNumber	- GL account reference
sub getGLAccount
{
	my ($data) = @_;


	my $GLAccID;

	# Check which 'mode' we operating in
	if (!defined($data->{'AccountID'}) || $data->{'AccountID'} < 1) {
		# Verify GL account ref
		if (!defined($data->{'AccountNumber'}) || $data->{'AccountNumber'} eq "") {
			setError("No (or invalid) account number provided");
			return ERR_PARAM;
		}

		# Check if account number exists
		if (($GLAccID = getGLAccountIDFromNumber($data->{'AccountNumber'})) < 1) {
			setError(Error());
			return $GLAccID;
		}
	} else {
		$GLAccID = $data->{'AccountID'};
	}

	# Verify account ID
	if (!$GLAccID || $GLAccID < 1) {
		setError("No (or invalid) account number or ID provided");
		return ERR_PARAM;
	}

	my $sth = DBSelect("
		SELECT
			gl_accounts.ID, gl_accounts.ParentGLAccountID, gl_accounts.Code, gl_accounts.Name,
			gl_financial_categories.Code AS FinCatCode, gl_financial_categories.Description AS FinCatDescription,
			gl_reportwriter_categories.Code AS RwCatCode, gl_reportwriter_categories.Description AS RwCatDescription
		FROM
			gl_accounts, gl_financial_categories, gl_reportwriter_categories
		WHERE
			gl_accounts.ID = ".DBQuote($GLAccID)."
			AND gl_financial_categories.ID = gl_accounts.FinCatID
			AND gl_reportwriter_categories.ID = gl_accounts.RwCatID
	");
	if (!$sth) {
		setError(wiaflos::server::dblayer::Error());
		return ERR_DB;
	}

	# Fetch row
	my $row = $sth->fetchrow_hashref();
	DBFreeRes($sth);

	# Check we got a result
	if (!defined($row)) {
		setError("Error finding account '$GLAccID'");
		return ERR_NOTFOUND;
	}


	return sanitizeRawGLAccountItem($row);
}


# Return the next sub account code
# Parameters:
#		AccountNumber	- GL account reference
sub getNextGLSubAccountCode
{
	my ($data) = @_;


	# Verify GL account number
	if (!defined($data->{'AccountNumber'}) || $data->{'AccountNumber'} eq "") {
		setError("No (or invalid) GL account number provided");
		return ERR_PARAM;
	}

	# Check GL account exists
	my $GLAccID;
	if (($GLAccID = getGLAccountIDFromNumber($data->{'AccountNumber'})) < 1) {
		setError(Error());
		return $GLAccID;
	}

	# Select last account
	my $sth = DBSelect("
		SELECT
			Code
		FROM
			gl_accounts
		WHERE
			ParentGLAccountID = ".DBQuote($GLAccID)."
		ORDER BY Code DESC
		LIMIT 1
	");
	if (!$sth) {
		setError(wiaflos::server::dblayer::Error());
		return ERR_DB;
	}

	# Fetch row
	my $row = $sth->fetchrow_hashref();
	DBFreeRes($sth);

	# Check we got a result, if not return 1
	if (!defined($row)) {
		return 1;
	}

	return $row->{'Code'} + 1;
}


## @fn getGLTransactions($data)
# Return an array of general ledger transactions
#
# @param data Parameter hash ref
# @li AccountID Limit transactions to those relating to this account
# @li StartDate	Optional start date
# @li EndDate Optional end date
# @li Type Optional transaction type
#
# @returns Array ref of hash refs
# @li ID GL entry ID
# @li TransactionDate Transaction date
# @li Reference GL entry reference
# @li Posted 0 if unposted, 1 if posted
# @li Type Transaction type
sub getGLTransactions
{
	my $data = shift;

	my @transactions = ();

	# Extra SQL we may need
	my $extraSQL = "";
	my $extraTables = "";
	my $extraEndSQL = "";

	# Check if we have an account ID
	if (defined($data->{'AccountID'}) && $data->{'AccountID'} > 0) {
		$extraTables .= ", gl_entries";
		$extraSQL .= "AND gl_entries.GLAccountID = ".DBQuote($data->{'AccountID'})." ";
		$extraSQL .= "AND gl_entries.GLTransactionID = gl_transactions.ID ";
		$extraEndSQL .= "GROUP BY gl_transactions.ID ";
	}

	# Check if we must use the start date
	if (defined($data->{'StartDate'}) && $data->{'StartDate'} ne "") {
		$extraSQL .= "AND gl_transactions.TransactionDate >= ".DBQuote($data->{'StartDate'})." ";
	}
	# Check if we must use the end date
	if (defined($data->{'EndDate'}) && $data->{'EndDate'} ne "") {
		$extraSQL .= "AND gl_transactions.TransactionDate <= ".DBQuote($data->{'EndDate'})." ";
	}

	# Check if we're filtering on type
	my $typeFilter = GL_TRANSTYPE_NORMAL;
	if (defined($data->{'Type'}) && $data->{'Type'} ne "") {
		$typeFilter = $data->{'Type'};
	}

	# Return list of GL transactions
	my $sth = DBSelect("
		SELECT
			gl_transactions.ID, gl_transactions.TransactionDate, gl_transactions.Reference,
			gl_transactions.Type,
			gl_transactions.Posted
		FROM
			gl_transactions $extraTables
		WHERE
			1 = 1
			$extraSQL
		$extraEndSQL
	");
	if (!$sth) {
		setError(wiaflos::server::dblayer::Error());
		return ERR_DB;
	}

	# Fetch rows
	while (my $row = $sth->fetchrow_hashref()) {
		# Check filter, if this is not one of our items, continue
		if (! ($typeFilter & $row->{'Type'})) {
			next;
		}

		my $transaction = sanitizeRawGLTransactionItem($row);

		push(@transactions,$transaction);
	}

	DBFreeRes($sth);

	return \@transactions;
}


# Return a hash containing a GL transaction
# Parameters:
#		ID	- Transaction ID
sub getGLTransaction
{
	my ($detail) = @_;


	# Verify params
	if (!defined($detail->{'ID'}) || $detail->{'ID'} < 1) {
		setError("Transaction ID not provided");
		return ERR_PARAM;
	}

	# Return list of GL transactions
	my $sth = DBSelect("
		SELECT
			ID, TransactionDate, Reference, Posted
		FROM
			gl_transactions
		WHERE
			ID = ".DBQuote($detail->{'ID'})."
	");
	if (!$sth) {
		setError(wiaflos::server::dblayer::Error());
		return ERR_DB;
	}

	# Fetch rows
	my $row = $sth->fetchrow_hashref();

	DBFreeRes($sth);

	# Check we got a result
	if (!$row) {
		setError("GL transaction '".$detail->{'ID'}."' not found");
		return ERR_NOTFOUND;
	}

	return sanitizeRawGLTransactionItem($row);
}


## @fn createGLTransaction($data)
# Create GL transaction
#
# @param data Parameter hash ref
# @li Date Date of transaction
# @li Reference Reference of transaction
# @li Type Optional transaction type
#
# @returns Transaction ID
sub createGLTransaction
{
	my ($detail) = @_;


	# Extra SQL we may need
	my $extraColumns = "";
	my $extraValues = "";

	# Verify date
	if (!defined($detail->{'Date'}) || $detail->{'Date'} eq "") {
		setError("No date provided for GL transaction");
		return ERR_PARAM;
	}

	# Verify reference
	if (!defined($detail->{'Reference'}) || $detail->{'Reference'} eq "") {
		setError("No reference provided for GL transaction");
		return ERR_PARAM;
	}

	# Verify type
	if (defined($detail->{'Type'}) && $detail->{'Type'} ne "") {
		$extraColumns .= ",Type";
		$extraValues .= ",".DBQuote($detail->{'Type'});
	}

	# Create GL transaction
	my $sth = DBDo("
		INSERT INTO gl_transactions
				(TransactionDate,Reference$extraColumns)
			VALUES
				(
					".DBQuote($detail->{'Date'}).",
					".DBQuote($detail->{'Reference'})."
					$extraValues
				)
	");
	if (!$sth) {
		setError(wiaflos::server::dblayer::Error());
		return ERR_DB;
	}

	# Grab last ID
	my $ID = DBLastInsertID("gl_transactions","ID");

	return $ID;
}


# Link GL transaction using account number instead of ID
# Parameters:
#		ID				- Transaction ID
#		GLAccountNumber	- GL account number
#		Amount			- Amount to post
#		Reference		- Transaction reference
sub linkGLTransactionByAccountNumber
{
	my ($data) = @_;


	# Check GL account exists
	my $GLAccID;
	if (($GLAccID = getGLAccountIDFromNumber($data->{'GLAccountNumber'})) < 1) {
		setError(Error());
		return $GLAccID;
	}

	# Add ID
	$data->{'GLAccountID'} = $GLAccID;

	# And Link
	return linkGLTransaction($data);
}


# Link GL transaction
# Parameters:
#		ID				- Transaction ID
#		GLAccountID		- GL account ID
#		Amount			- Amount to post
#		Reference		- Transaction reference
sub linkGLTransaction
{
	my ($data) = @_;


	# Verify params
	if (!defined($data->{'ID'}) || $data->{'ID'} < 1) {
		setError("Transaction ID not provided");
		return ERR_PARAM;
	}

	if (!defined($data->{'GLAccountID'}) || $data->{'GLAccountID'} < 1) {
		setError("Account ID not provided for transaction '".$data->{'ID'}."'");
		return ERR_PARAM;
	}

	if (!defined($data->{'Amount'}) && !defined($data->{'Credit'}) && !defined($data->{'Debit'})) {
		setError("Amount or Credit or Debit must be specified");
		return ERR_PARAM;
	}
	if (defined($data->{'Credit'}) && defined($data->{'Debit'})) {
		setError("Parameter 'Credit' and 'Debit' cannot be specified for the same transcation");
		return ERR_PARAM;
	}
	if ((defined($data->{'Credit'}) && defined($data->{'Amount'})) || (defined($data->{'Debit'}) && defined($data->{'Amount'}))) {
		setError("Parameter 'Credit'/'Debit' is incompatible with 'Amount'");
		return ERR_PARAM;
	}

	# Lets get some account info
	my $params;
	$params->{'AccountID'} = $data->{'GLAccountID'};
	my $account = getGLAccount($params);
	if (ref $account ne "HASH") {
		return $account;
	}

	# Pull in amount
	my $cleanAmount = Math::BigFloat->new();
	$cleanAmount->precision(-2);

	# Lets see what we going to pull in...
	# We use ABS to get positive value no matte what
	# We use bneg() to negate this in case of a debit
	if (defined($data->{'Credit'})) {
		$cleanAmount->badd($data->{'Credit'})->babs();
		# NK: Credit vs. Debit based on account type, are we going to reverse this?
		foreach my $finCatCode ("A01", "B01", "D01", "E01") {
			# Check for match
			if ($account->{'FinCatCode'} eq $finCatCode) {
				$cleanAmount->bneg();
				last;
			}
		}
	} elsif (defined($data->{'Debit'})) {
		$cleanAmount->bsub($data->{'Debit'})->babs();

		# NK: Credit vs. Debit based on account type, are we going to reverse this?
		foreach my $finCatCode ("B01","C01","D01") {
			# Check for match
			if ($account->{'FinCatCode'} eq $finCatCode) {
				last;
			}
		}

	} elsif (defined($data->{'Amount'})) {
		$cleanAmount->badd($data->{'Amount'});
	}

	#NK - wtf .... should we or shouldn't we check?
	# still not sure, its disabled for a reason I guess ... ??
#	if ($cleanAmount->is_zero()) {
#		setError("Amount cannot be zero");
#		return ERR_AMTZERO;
#	}

	# Decide what to do with ref
	my $ref = defined($data->{'Reference'}) ? DBQuote($data->{'Reference'}) : "NULL";

	# Return list of GL transactions
	my $sth = DBSelect("
		SELECT
			Posted
		FROM
			gl_transactions
		WHERE
			ID = ".DBQuote($data->{'ID'})."
	");
	if (!$sth) {
		setError(wiaflos::server::dblayer::Error());
		return ERR_DB;
	}

	my $row = $sth->fetchrow_hashref();
	DBFreeRes($sth);

	# Check we got a result
	if (!defined($row)) {
		setError("Error finding transaction '".$data->{'ID'}."'");
		return ERR_NOTFOUND;
	}

	# Check if we not posted
	if ($row->{'Posted'} == '1') {
		setError("Cannot link to a posted transaction '".$data->{'ID'}."'");
		return ERR_POSTED;
	}

	# Create GL entry
	$sth = DBDo("
		INSERT INTO gl_entries
				(GLTransactionID,GLAccountID,Reference,Amount)
			VALUES
				(
					".DBQuote($data->{'ID'}).",
					".DBQuote($data->{'GLAccountID'}).",
					$ref,
					".DBQuote($cleanAmount->bstr())."
				)
	");
	if (!$sth) {
		setError(wiaflos::server::dblayer::Error());
		return ERR_DB;
	}