#!/usr/bin/perl -T 

# register.cgi

# Modification History
#	0.01 (20020410) tallan    - Created - Fork from abstract.
#	0.02 (20020411) tallan    - Completed basic functionality.
#	0.03 (20020413) tallan    - set $user = $new_user so that all changes are captured
#							and a new app event 'new-reg'
#							allow member number to be omitted for Non-members
#	0.04 (20020415) tallan    - fix amount due missing error
#	0.05 (20020416) tallan    - fix amount due missing error for new users in the database
#	0.06 (20020506) tallan    - delegate string reduced to just 'Delegate'.
#	0.07 (20020509) tallan    - close breakfast or close registrations parameters.
#	0.10 (20020714) tallan    - (incomplete) generalisation for cmga2002.
#	0.11 (20020719) tallan    - add cmga2002 business rules.
#	0.12 (20020721) tallan    - fix misc. bugs.
#	0.13 (20020728) tallan    - add noemail parameter. save reg-type, payment-type as encoded values
#       0.14 (20020807) tallan    - if the registration is speaker or speaker1, then set the registration to speaker
#       0.15 (20030705) tallan	  - updated for cmga2003
#       0.16 (20040718) tallan    - updated for cmga2004
my $version = "0.16 (20030718)";

use strict;
use warnings;
use lib '../../lib';
use Data::Dumper;
use APMS;
use APMS::Instrument;
use APMS::CGIRequest;
use APMS::CGIResponse;
use APMS::CGIForm;
use APMS::User;
use APMS::Paper;
use APMS::Event;


# -----------------------------------------------------------------------------
# Initialisation...

my $config = new APMS::Config();
$config->version($version);
my $debug = 9;

my $instrument = new APMS::Instrument();
my $request = new APMS::CGIRequest(5000);
my $login = '';
if ($request->param('login')) {
	$login = APMS::login($request, $instrument);
}
my $response = new APMS::CGIResponse($request, 200);

unless ($response->template('register')) {
	printf($config->get_resource('template') . "\n", 'register');
}

# -----------------------------------------------------------------------------
# Did we get a good event?

my $event;
my $event_name;
if ($event = $request->param('event')) {
	$response->param('event', $event);
	$event_name = $config->get('event', $event, 'name');
	if ($event_name) {
		$response->param('event_name', $event_name);
	}
	else {
		$response->push_param('errors', 
			{'error' => sprintf($config->get_resource('bad-event'), $event)});
		print STDERR "[script parameter error] " . 
			sprintf($config->get_resource('bad-event'), $event) . 
			"\n" if ($debug);
		my $bytes = $response->finalise();
		$instrument->stop('failed');
		exit 0;
	}
}
else {
	$response->push_param('errors', 
		{'error' => $config->get_resource('no-event')});
		print STDERR "[script parameter error] " . 
			$config->get_resource('no-event') . 
			"\n" if ($debug);
	my $bytes = $response->finalise();
	$instrument->stop('failed');
	exit 0;
}
# -----------------------------------------------------------------------------
my $customer = $config->get('customer.name');
$response->param('title', 	"$customer - Event Registration for $event_name");
$response->param('title1', 	"Event Registration for $event_name");
$response->param('menu', [
#                     { url => "/$event/", label => "$event_name" },
                     { url => '/apps/user/', label => 'User Functions' },
                  ] );
$response->no_more('menu');
$response->param('customer', $customer);
$response->param('width', '20%');

# check if we are admin and if the user email should be supressed
my $no_email;
if ($login) {
	if ($login->is_admin()) {
		$response->param('admin', $login);
		$response->no_more('admin');
		if ($request->param('noemail')) {
			$no_email = 'true';
			$response->param('noemail', 'true');
			$response->no_more('noemail');
		}
	}
}

my $command = $request->param('cmd') || '';
if ($command eq 'edit') {
	$response->push_param('errors', 
		{'error' => $config->get_resource('edit')});
	print STDERR "[intentional validation error] " .
		$config->get_resource('edit') .
		"\n" if ($debug);
}

# see if registrations are still open
my $closed_reg = $config->get("event.$event.close-registration") || 0;
if ($closed_reg) {
	$response->param('closed_reg', "true");
	print STDERR "$customer - $event Registration Closed.\n";
}
#my $closed_br = $config->get("event.$event.close-breakfast") || 0;
#if ($closed_br) {
#	$response->param('breakfast_closed', "true");
#	print STDERR "$customer - $event Breakfast Registration Closed.\n";
#}
#else {
#	$response->param('breakfast', "true");
#}


my $user;
my $flag_new_user = 0;
my $old_user_id;

# non-form error count
my $other_errors = 0;

# define a new user, just in case
my $new_user = new APMS::User();

# and somewhere to save our new attributes (if an existing user)
my %attributes;
my %attributes_email;

my $form = new APMS::CGIForm($request, $response, 'abstract');
$form->process(
	sub {
		my ($parm, $value) = @_;
		my $dont_set = $config->get("form.abstract.$parm.dont-set");
		if ($parm) {
			unless ($dont_set) {
				$attributes_email{$parm} = $value;
			}
			if ($parm =~ /^reg/) {
				$parm = "event.$event.$parm";
				$attributes{$parm} = $value;
			}
			unless ($dont_set) {
				$new_user->set($parm, $value);
			}
			$value = 'unknown' unless ($value);
			print STDERR "[register] setting $parm to $value\n" if($debug);
		}
	});

# Add a list of countries
my $country = $request->param('person.country') || 'Australia';
$response->param('countries', APMS::CGIForm::Countries($country));
$response->no_more('countries');

# check if we are capturing seminar data
my $capture_sem = $config->get("event.$event.capture-sem") || 0;
if ($capture_sem) {
        $response->param('capture-sem', 'true');
}

if ($command) {
	if (my $userid = $request->param('userid')) {
		$user = new APMS::User($userid);
		if ($user) {
			$user->authenticate($request->param('password'));
			if ($user->is_authenticated()) {
				$response->param('user', $user->as_string());
				$response->param('userid', $userid);
				$response->param('password', $request->param('password'));
				$response->push_param('details', $user->get_all());
				$response->no_more('details');
				$old_user_id = $userid;

				# capture some data for the email
				$attributes_email{'person.firstname'} = $user->get('person.firstname');
				$attributes_email{'person.lastname'}  = $user->get('person.lastname');
				$attributes_email{'person.company'}   = $user->get('person.company');
			}
			else {
				$response->push_param('errors', 
					{'error' => $config->get_resource('bad-userid')});
				print STDERR "[userid error] " . 
					$config->get_resource('bad-userid') . 
					"\n" if ($debug);
				$form->validate('password');
			}
		}
		else {
			$response->push_param('errors', 
				{'error' => $config->get_resource('in-userid')});
			print STDERR "[userid error] " . 
				$config->get_resource('in-userid') . 
				"\n" if ($debug);
		}
	}
	else {
		$flag_new_user = 1;
		$form->validate('person.title');
		$form->validate('person.firstname');
		$form->validate('person.lastname');
		$form->validate('person.position');
		$form->validate('person.company');
		$form->validate('person.address1');
		$form->validate('person.address2');
		$form->validate('person.city');
		$form->validate('person.state');
		$form->validate('person.postcode');
		$form->validate('person.country');
		$form->validate('person.telephone');
		$form->validate('person.mobile');
		$form->validate('person.facsimile');
		$form->validate('person.email');
	}

	$form->validate('reg.reg-type');
	$form->validate('reg.mem-type');
	$form->validate('reg.dietary-reqts');
	$form->validate('reg.payment-type');
	if ($capture_sem) {
		$form->validate('reg.sem-morning');
		$form->validate('reg.sem-afternoon');
	}
	$form->validate('reg.social');
	$form->validate('reg.partner');
	#$form->validate('reg.partner.name');
	#$form->validate('reg.partner.dietary-reqts');

	# check rule: If Partner / Guest is specified, then a "Name for Badge" must also be specified.
	if (($request->param('reg.partner') || '') eq 'Yes') {
		unless ($request->param('reg.partner.name')) {
			$response->push_param('errors', 
				{'error' => $config->get_resource('no-partner-name')});
			print STDERR "[rule error] " . 
				$config->get_resource('no-partner-name') . 
				"\n" if ($debug);
			$other_errors++;
		}

		# while we are here, set a flag to display the message in the cost text
		$response->param('reg.partner-msg', 'true');

		# only validate other partner info if partner is specified
		$form->validate('reg.partner.name');
		$form->validate('reg.partner.dietary-reqts');
	}

	# work out the cost if we have the correct info
	my $regmt = $request->param('reg.mem-type') || '';
	my $regrt = $request->param('reg.reg-type') || '';
	#my $seminars = 0;

	my $cost = $config->get("event.$event.cost.$regrt.$regmt") || 0;

	#if ($regrt eq 'conf-sem') {
	#	$seminars = 1;
	#	if ($regmt eq 'Non-member') {
	#		#$cost = 2500;
	#		$cost = 1950;
	#	}
	#	elsif ($regmt eq 'Member') {
	#		#$cost = 2200;
	#		$cost = 1700;
	#	}
	#}
	#elsif ($regrt eq 'conf') {
	#	if ($regmt eq 'Non-member') {
	#		$cost = 1950;
	#	}
	#	elsif ($regmt eq 'Member') {
	#		$cost = 1700;
	#	}
	#}
	#elsif ($regrt eq 'one-wed') {
	#	$seminars = 1;
	#	if ($regmt eq 'Non-member') {
	#		$cost = 975;
	#	}
	#	elsif ($regmt eq 'Member') {
	#		$cost = 850;
	#	}
	#}
	#elsif ($regrt eq 'one-thur') {
	#	if ($regmt eq 'Non-member') {
	#		$cost = 975;
	#	}
	#	elsif ($regmt eq 'Member') {
	#		$cost = 850;
	#	}
	#}
	#elsif ($regrt eq 'one-fri') {
	#	if ($regmt eq 'Non-member') {
	#		$cost = 975;
	#	}
	#	elsif ($regmt eq 'Member') {
	#		$cost = 850;
	#	}
	#}
	#elsif ($regrt eq 'speaker') {
	#	$seminars = 1;
	#	$cost = 600;
	#}
	#elsif ($regrt eq 'speaker1') {
	#	$cost = 0;
	#}

	# check rules if we are collecting seminar data
	if ($capture_sem) {
		# check rule: Both seminars must be specified if attending on the seminar day (Wednesday).
		if ($config->get("event.$event.seminar.$regrt")) {
			my $m = $request->param('reg.sem-morning');
			my $a = $request->param('reg.sem-afternoon');
			if ((!$m) || (!$a)) {
				$response->push_param('errors', 
					{'error' => $config->get_resource('seminars')});
				print STDERR "[rule error] " . 
					$config->get_resource('seminars') . 
					"\n" if ($debug);
				$other_errors++;
			}
		}
		# check rule: You selected one or both seminars but are not attending on Wednesday.
		else {
			my $m = $request->param('reg.sem-morning')   || '';
			my $a = $request->param('reg.sem-afternoon') || '';
			if (($m ne '') || ($a ne '')) {
				$response->push_param('errors', 
					{'error' => $config->get_resource('wednesday')});
				print STDERR "[rule error] " . 
					$config->get_resource('wednesday') . 
					"\n" if ($debug);
				$other_errors++;
			}
		}
	}

#	else {
#		$response->push_param('errors', 
#			{'error' => $config->get_resource('reg-type')});
#		print STDERR "[validation error] " . $config->get_resource('reg-type');
#		$other_errors++;
#		$cost = 0;
#	}

	my $partner = $request->param('reg.partner') || '';
	if ($partner eq 'Yes') {
		$cost += $config->get("event.$event.cost.partner") || 0;
	}

	#if ($cost) {
		my $gst = int($cost / 10);

		my $amount_due = sprintf("%.2f", $cost + $gst);
		$response->param('cost', 	$amount_due);
		$response->param('cost-nogst', 	sprintf("%.2f", $cost));
		$response->param('gst', 	sprintf("%.2f", $gst));

		$attributes{"event.$event.reg.amount-due"}  = '$' . $amount_due;
		$attributes_email{'reg.amount-due'} 	    = '$' . $amount_due;
		$new_user->set("event.$event.reg.amount-due", '$' . $amount_due);

	#}
}

foreach my $e ($form->errors()) {
	$response->push_param('errors', {'error' => $e});
	print STDERR "[validation error] $e\n" if ($debug);
}
$response->no_more('errors');

# admin users can add incomplete data
my $form_errors = $form->errors() + $other_errors;
if ($login) {
	if ($login->is_admin()) {
		$form_errors = 0;
		#$response->param('admin', 'true');
	}
}
$response->no_more('admin');


if ($command eq 'validate') {
	if ($form_errors) {
		$response->param('form', 'true');
	}
	else {
		$response->param('summary', 'true');
		$response->param('check',   'true');
	}
}
elsif ($command eq 'edit') {
	$response->param('form', 'true');

}
elsif ($command eq 'process') {
	my $new_user_id;
	if ($form_errors) {
		$response->param('form', 'true');
	}
	else {
		$response->param('summary',    'true');
		$response->param('submission', 'true');
		if ($flag_new_user) {
			# values already added to the object
			$new_user_id = $new_user->add();
			if ($new_user_id) {
				$response->param('new_user_id', $new_user_id);
				APMS::Event::Record("new-user", "NOTICE", 
					"$login Creating new user $new_user_id - $new_user");
				
				# this worked so set $user so final changes work
				$user = $new_user;
			}
		}
		else {
			foreach my $k (keys %attributes) {
				my $a = $attributes{$k};
 				if ($user) {
					if ($user->is_authenticated()) {
						if ($a) {
							$user->update($k, $a);
							print STDERR "[user update] setting $k to $a\n" if($debug);
						}
						else {
							print STDERR "[user   null] not setting null $k\n" if($debug);
						}
					}
					else {
						print STDERR "[user unauth] cannot set " .
							"$a to $k for unauthenticated user $old_user_id\n" if($debug);
					}
				}
			}
		}

  		my $reg_reg_type	= $request->param('reg.reg-type') || '';
  		#my $reg_reg_type	= $config->get('form.abstract.reg.reg-type.n.' . 
		#			($request->param('reg.reg-type') || '')) || 'unknown - error';
 		$user->update("event.$event.reg.reg-type", $reg_reg_type);
		$attributes_email{"reg.reg-type"} = $reg_reg_type;
		print STDERR "[register] setting user event.$event.reg.reg-type to $reg_reg_type\n" 
			if($debug);

  		if ($capture_sem) {
			my $reg_sem_morning	= $request->param('reg.sem-morning') || '';
  			#my $reg_sem_morning	= $config->get('form.abstract.reg.sem-morning.n.' . 
			# 			  ($request->param('reg.sem-morning') || '')) || 'none';
			$user->update("event.$event.reg.sem-morning", $reg_sem_morning);
			$attributes_email{"reg.sem-morning"} = $reg_sem_morning;
			print STDERR "[register] setting user event.$event.reg.sem-morning to $reg_sem_morning\n" 
				if($debug);

 			my $reg_sem_afternoon	= $request->param('reg.sem-afternoon') || '';
 			#my $reg_sem_afternoon	= $config->get('form.abstract.reg.sem-afternoon.n.' . 
			#			  ($request->param('reg.sem-afternoon') || '')) || 'none';
			$user->update("event.$event.reg.sem-afternoon", $reg_sem_afternoon);
			$attributes_email{"reg.sem-afternoon"} = $reg_sem_afternoon;
			print STDERR "[register] setting user event.$event.reg.sem-afternoon to " .
				"$reg_sem_afternoon\n" if($debug);
		}

		my $pay = $request->param('reg.payment-type') || '';
		if ($pay eq 'cheque') {
			$response->param('pay-cheque',	'true');
 		}
		elsif ($pay eq 'po') {
			$response->param('pay-po',	'true');
 		}
		elsif ($pay eq 'ccard') {
			$response->param('pay-cc',	'true');
 		}

		my $id   = $new_user_id || $old_user_id || '';
		my $ref  = "$id/" . $config->date('internal') || '';

		$response->param('reference', $ref);
		$user->update("event.$event.reg.reference", $ref);
		print STDERR "[user update] setting user 'event.$event.reg.reference' " .
				"to $ref\n" if($debug);

		$user->update("event.$event.reg.payment-status", 'initial-submission');

		if ($reg_reg_type =~ /^speaker/) {
			$user->update("event.$event.reg.registration", 'speaker');
		}
		else {
                        $user->update("event.$event.reg.registration", 'delegate');
                }

		print STDERR "[user update] setting 'event.$event.reg.payment-status' " .
				"to 'initial-form-submission'\n" if($debug);

		# and an application event
		APMS::Event::Record("new-reg", "NOTICE", 
			"$login Creating new registration $ref for $user");

		# and finally, an email to the user
		my $date 	 = $config->date();
		my $script	 = $config->get('system.script') || '';
		my $app  	 = $config->get('system.app') || '';
		my $ver		 = $config->get('system.version') || '';
		my $customer = $config->get('customer') || '';
		my $custname = $config->get('customer.name') || '';

		my $mailprog = $config->get('module.event.mailprog');
		if ($mailprog) {
			my $replyto 	= $config->get('module.event.replyto') || 'root';
			my $path 		= $config->get('module.event.path') || '';
			my $email 		= $user->get("person.email") || '';
			if ($email && !$no_email) {
				$ENV{'PATH'} = $path;
				open (MAIL, "|$mailprog -t");
				print MAIL "To: $email\n";
				print MAIL "Reply-To: $replyto\n";
				print MAIL "From: $replyto\n";
				print MAIL "Subject: [$customer] Event Registration for $event_name\n";
				print MAIL "\n";
				print MAIL "Registration Data:\n\n";

				$attributes_email{'reg.reference'} = $ref;
				my $width = $config->get('module.event.email-width') || 20;
				print STDERR "[register email] Width: $width\n" if($debug);
				foreach my $k (sort keys %attributes_email) {
					my $a = $attributes_email{$k};
					if ($a) {
						my $text = $config->get("form.abstract.$k.label") || '';
						my $space = ' ' x ($width - length($text));
						print MAIL "$text:$space $a\n";
					}
				}
				print MAIL "\n";
				print MAIL "Your registration for $event_name has been received and successfully ";
				print MAIL "recorded in the $customer database.\n";
				print MAIL "\n";
				print MAIL "Your Registration will not be confirmed until your payment has ";
				print MAIL "been received and processed. You will be notified by e-mail once ";
				print MAIL "we have received and processed your payment.\n";
				print MAIL "\n---------------------------------------------------\n";
				print MAIL "$app/$script/$ver\n";
				close(MAIL);
				print STDERR "$date $customer [$script/$ver] Email to $email\n" if($debug);
			}
			else {
				print STDERR "$date $customer [$script/$ver] " .
					"No person.email defined for " . $user->as_string() . "\n";
			}
		}
		else {
			print STDERR "$date $customer [$app/$script] " .
				"No mail program defined in 'module.event.mailprog'\n";
		}

	}
}
else { # new form
	unless ($closed_reg) {
		$response->param('form', 'true');
		#$response->param('person.title.mr', 'SELECTED');
		#$response->param('initial.default', 'SELECTED');
	}
}

# -----------------------------------------------------------------------------
my $bytes = $response->finalise();
$instrument->stop('good', $bytes, 'byte');