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

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

use lib '/app/tools/common/lib';
use Common::Assert;
use Common::DB::Item::Country;

use lib '/app/tools/rps/lib';
use RPS::DB::Item::LabelContract;
use RPS::DB::Item::LabelContractGroupTermException;
use RPS::DB::Item::Label;
use RPS::DB::Item::Service;

use Common::FormObject;
use base 'Common::FormObject';


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

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

    my %properties;

    if($args{_dbItem})
    {
        $self->_propertiesFromDBItem(\%properties, $args{_dbItem});
    }
    elsif($args{labelContractGroupTermExceptionID})
    {
        $self->_propertiesFromDB(\%properties, $args{labelContractGroupTermExceptionID});
    }
    else
    {
        $self->_propertiesFromDefaults(\%properties, $args{labelContractGroupExceptionID});
    }

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

    return $self;
}


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

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


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

	$self->{_inDB} = 1;

    $hrProperties->{label_contract_group_term_exception_id} = $dbItem->label_contract_group_term_exception_id;
    $hrProperties->{priority} = $dbItem->priority;
    $hrProperties->{label_contract_group_term_id} = $dbItem->label_contract_group_term_id;
    $hrProperties->{service_id} = $dbItem->service_id;
    $hrProperties->{country_code} = $dbItem->country_code;
    $hrProperties->{distribution_fee} = $dbItem->distribution_fee;

    $hrProperties->{date_created} = $dbItem->date_created;
    $hrProperties->{date_modified} = $dbItem->date_modified;
    $hrProperties->{created_by} = $dbItem->created_by;
    $hrProperties->{modified_by} = $dbItem->modified_by;
}


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

    $self->{LabelContractGroupTermExceptionID}	 = Common::FormObject::Scalar->new(value => $props->{label_contract_group_term_exception_id}, readOnly => 1);
    $self->{Priority} = Common::FormObject::Scalar->new(value => $props->{priority});    
    $self->{LabelContractGroupTermID} = Common::FormObject::Scalar->new(value => $props->{label_contract_group_term_id});    
    $self->{ServiceID}		        = Common::FormObject::Scalar->new(value => $props->{service_id});
    $self->{CountryCode}		    = Common::FormObject::Scalar->new(value => $props->{country_code});
    $self->{DistributionFee}		= Common::FormObject::Scalar::Percent->new(value => $props->{distribution_fee});

    $self->{CreatedDate}		= Common::FormObject::Scalar::DateTime->new(value => $props->{date_created}, readOnly => 1);
    $self->{ModifiedDate}		= Common::FormObject::Scalar::DateTime->new(value => $props->{date_modified}, readOnly => 1);
    $self->{CreatedBy}			= Common::FormObject::Scalar::UserName->new(value => $props->{created_by}, readOnly => 1);
    $self->{ModifiedBy}			= Common::FormObject::Scalar::UserName->new(value => $props->{modified_by}, readOnly => 1);

    # Going to grab the service, so we can include the service name for sorting purposes.
    #
    my $serviceName = "All";
    if ($props->{service_id})
    {
        my $service = RPS::DB::Item::Service->Lookup(service_id => $props->{service_id});
        $serviceName = $service->service_name;
    }
	$self->{ServiceName} = Common::FormObject::Scalar::String->new(value => $serviceName, readOnly => 1);   
	
    # Let's do the same thing for country.
    #
    my $countryName = "All";
    if ($props->{country_code})
    {
        my $country = Common::DB::Item::Country->Lookup(alpha2 => $props->{country_code});
        $countryName = $country->name;
    }
	$self->{CountryName} = Common::FormObject::Scalar::String->new(value => $countryName, readOnly => 1);  	 

	# the default is 'OFF' (ie. don't delete)
	#
	$self->{Delete} = Common::FormObject::Scalar::Boolean->new();
}


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

}


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

    $hrProperties->{label_contract_group_term_id} = $labelContractGroupTermID;
}

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

    if ($self->Delete())
    {
        if ($self->hasDependency())
        {
            $self->{Delete}->setError('has_dependency');
            return 0;
        }
        # else, no need to validate any properties
        return 1;
    }

	foreach my $field (qw(ServiceID CountryCode DistributionFee))
	{
		if (defined $self->$field() && $self->$field() ne '')
		{
			$self->{_hasData} = 1;
		}
	}
	
	if ($self->{_hasData})
	{
		my $valid = $self->SUPER::validate();

        if (!$self->ServiceID && $self->ServiceID ne '0')
        {
            $self->{ServiceID}->setError(Common::FormObject::kErrFieldBlank);
            $valid = 0;
        }

        if (!$self->CountryCode && $self->CountryCode ne '0')
        {
            $self->{CountryCode}->setError(Common::FormObject::kErrFieldBlank);
            $valid = 0;
        }

        if (!$self->DistributionFee && $self->DistributionFee ne '0')
        {
            $self->{DistributionFee}->setError(Common::FormObject::kErrFieldBlank);
            $valid = 0;
        }        

        if ($self->ServiceID eq 'ALL' && $self->CountryCode eq 'ALL')
        {
            $self->{ServiceID}->setError(Common::FormObject::kErrFieldDuplicate);
            $self->{CountryCode}->setError(Common::FormObject::kErrFieldDuplicate);
            $valid = 0;
        }
        
		
        return $valid;
	}
	else
	{
		return 1;
	}
}

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

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

    return unless $self->{_hasData};


	my $dbObj;
	if($self->LabelContractGroupTermExceptionID())
	{
		$dbObj = RPS::DB::Item::LabelContractGroupTermException->Lookup(label_contract_group_term_exception_id => $self->LabelContractGroupTermExceptionID());
        $dbObj->modified_by($self->ModifiedBy());
        $dbObj->date_modified(Common::DB::Item::kDateTimeNow);
	}
	else
	{
		$dbObj = RPS::DB::Item::LabelContractGroupTermException->Create();
        $dbObj->created_by($self->CreatedBy());
        $dbObj->date_created(Common::DB::Item::kDateTimeNow);
	}

	# set fields here
	#
	my $countryCode = $self->CountryCode();
	if (uc($countryCode) eq 'ALL') {
	    $countryCode = 0;
	}
	my $serviceID = $self->ServiceID();
	if (uc($serviceID) eq 'ALL') {
	    $serviceID = 0;
	}  	    
	
	$dbObj->service_id($serviceID);
	$dbObj->country_code($countryCode);
	$dbObj->distribution_fee($self->DistributionFee());
    $dbObj->label_contract_group_term_id($self->LabelContractGroupTermID());

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

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

sub setDependency
{
	my $self = shift;
    $self->{HasDependency} = 1;
}

sub hasDependency
{
	my $self = shift;
    return $self->{HasDependency} ? 1 : 0;
}

sub delete
{
	my $self = shift;

	if($self->{_inDB})
	{
		my $myDBObj = RPS::DB::Item::LabelContractGroupTermException->Lookup(label_contract_group_term_exception_id => $self->LabelContractGroupTermExceptionID());
		$myDBObj->delete();
	}
    return 1;
}


###
1;#
###