#------------------------------------------------------------ 
# Copyright (C) 2006 RoyaltyShare, Inc.   All Rights Reserved
# $Id$
#------------------------------------------------------------ 
package RPS::Contract::Deduction;

use strict;
use Carp;
use Data::Dumper;

use lib '/app/tools/common/lib';
use Common::Assert;

use lib '/app/tools/rps/lib';
use RPS::DB::Item::ArtistContractDeduction;
use RPS::Contract::DeductionType;

use RPS::XMLObject;
use base 'RPS::XMLObject';


sub _init
{
    my ($self, %args) = @_;

    $self->SUPER::_init(%args);

    my %properties;
    if ($args{_dbItem})
    {   
        $self->_propertiesFromDBItem(\%properties, $args{_dbItem});
    }
    elsif ($args{deductionID})
    {   
        $self->_propertiesFromDB(\%properties, $args{deductionID});
    }
    else
    {   
        $self->_propertiesFromDefaults(\%properties, $args{contractID}, $args{contractMode});
    }

    $self->_initProperties(\%properties);
    $self->_initSubs(\%properties);

    return $self;
}


sub _propertiesFromDB
{   
    my ($self, $hrProperties, $id) = @_;

    my $dbItem = RPS::DB::Item::ArtistContractDeduction->Lookup(artist_contract_deduction_id => $id);
    $self->_propertiesFromDBItem($hrProperties, $dbItem);
}


sub _propertiesFromDBItem
{
	my ($self, $hrProperties, $dbItem) = @_;

	$self->{_inDB} = 1;

    $hrProperties->{artist_contract_deduction_id} = $dbItem->artist_contract_deduction_id;
    $hrProperties->{artist_contract_id} = $dbItem->artist_contract_id;
    $hrProperties->{contract_mode} = $dbItem->contract_mode;
    $hrProperties->{deduction_type_id} = $dbItem->deduction_type_id;
    $hrProperties->{percent} = $dbItem->percent;
}


sub _initProperties
{
    my ($self, $props) = @_;

    $self->{ArtistContractDeductionID}	= RPS::XMLObject::Scalar::Integer->new(value => $props->{artist_contract_deduction_id});
    $self->{ArtistContractID}			    = RPS::XMLObject::Scalar::Integer->new(value => $props->{artist_contract_id}, required => 1);
    $self->{ContractMode}     				= RPS::XMLObject::Scalar::Integer->new(value => $props->{contract_mode}, required => 1);
    $self->{DeductionTypeID}				= RPS::XMLObject::Scalar::Integer->new(value => $props->{deduction_type_id}, required => 1);
    $self->{Percent}						= RPS::XMLObject::Scalar::Percent->new(value => $props->{percent}, required => 1);

	# this is how the template tells the backend to delete one of these.
	# the default is 'OFF' (ie. don't delete)
	#
	$self->{Delete} = RPS::XMLObject::Scalar->new();
}


sub _initSubs
{
    my ($self, $props) = @_;

	if($self->loadSubs())
    {
	    $self->{DeductionType} = RPS::Contract::DeductionType->new(deductionTypeID => $props->{deduction_type_id}, readOnly => 1);
    }
}


sub _propertiesFromDefaults
{
    my ($self, $hrProperties, $contractID, $contractMode) = @_;

    assert($contractID);
    assert($contractMode);

	my $contract = RPS::DB::Item::ArtistContract->Lookup(artist_contract_id => $contractID);
    assert($contract);

    $hrProperties->{artist_contract_id} = $contractID;
    $hrProperties->{contract_mode} = $contractMode;
}



sub validate
{
    my ($self) = @_;

    # If this guy is being deleted, we don't really care what values it has...
    #
    if ($self->Delete())
    {
        return 1;
    }

	my $valid = 1;

	# only validate if something was entered
	#
	if(defined $self->Percent() || defined $self->DeductionTypeID())
	{
		$valid =  $self->SUPER::validate();

		if($self->Percent() <= 0)
		{
			$self->{Percent}->setError(RPS::XMLObject::kErrFieldInvalid);
			$valid = 0;
		}
	}

	return $valid;
}

sub save
{
    my ($self) = @_;

	if($self->Delete())
	{
		$self->delete();
		return;
	}

	my $dbObj;
	if($self->ArtistContractDeductionID())
	{
		$dbObj = RPS::DB::Item::ArtistContractDeduction->Lookup(artist_contract_deduction_id => $self->ArtistContractDeductionID());
	}
	else
	{
		$dbObj = RPS::DB::Item::ArtistContractDeduction->Create();
	}

	# set fields here
	#
	$dbObj->artist_contract_id($self->ArtistContractID());
	$dbObj->contract_mode($self->ContractMode());
	$dbObj->deduction_type_id($self->DeductionTypeID());
	$dbObj->percent($self->Percent());

	# save db item
	#
	$dbObj->save();

	# reload object
	#
	$self->_init(_dbItem => $dbObj);
}

sub delete
{
	my $self = shift;

	if($self->{_inDB})
	{
		my $myDBObj = RPS::DB::Item::ArtistContractDeduction->Lookup(artist_contract_deduction_id => $self->ArtistContractDeductionID());
		$myDBObj->delete();
		$self->{_inDB} = 0;
	}
	return 1;
}


###
1;#
###