webgui_newsletter/lib/WebGUI/AssetAspect/Subscriber.pm

package WebGUI::AssetAspect::Subscriber;

use strict;
use warnings;
use Class::C3; 

use WebGUI::Macro;
use Tie::IxHash;

#----------------------------------------------------------------------------
sub definition {
	my $class       = shift;
	my $session     = shift;
	my $definition  = shift;
#	my $i18n        = WebGUI::International->new( $session,'AssetAspect_Subscriber' );

	tie my %properties, 'Tie::IxHash', (
        subscriptionGroupId         => {
            fieldType       => 'subscriptionGroup',
            label           => 'Subscription group',
            tab             => 'subscription',
            noFormPost      => 1,
        },
        subscriptionEnabled         => {
            fieldType       => 'yesNo',
            defaultValue    => 1,
            label           => 'Enable subscription',
            tab             => 'subscription',
        },
        alwaysConfirmSubscription   => {
            fieldType       => 'yesNo',
            defaultValue    => 0,
            label           => 'Always require subscription confirmation',
            tab             => 'subscription',
        },
        allowAnonymousSubscription  => {
            fieldType       => 'yesNo',
            defaultValue    => 1,
            label           => 'Allow anonymous subscription',
            tab             => 'subscription',
        },
	);

	push( @{ $definition }, {
		autoGenerateForms   => 1,
		tableName           => 'assetAspectSubscriber',
		className           => 'WebGUI::AssetAspect::Subscriber',
		properties          => \%properties
	} );

	return $class->next::method( $session, $definition );
}

#----------------------------------------------------------------------------
sub duplicate {
    my $self        = shift;
    my $properties  = shift;
    my $newSelf     = $self->next::method( $properties );

    $newSelf->update({ subscriptionGroupId => '' });
    $newSelf->createSubscriptionGroup;

    return $newSelf;
}

#----------------------------------------------------------------------------
sub getEditTabs {
    my $self = shift;

    return ( $self->next::method, [ 'subscription', 'Subscription', 9 ] );
}

#----------------------------------------------------------------------------
sub canSubscribe {
    my $self = shift;

    return !$self->session->user->isVisitor && !$self->isSubscribed;
}

#----------------------------------------------------------------------------
sub canUnsubscribe {
    my $self = shift;

    return !$self->session->user->isVisitor && $self->isSubscribed;
}

#----------------------------------------------------------------------------
sub createSubscriptionGroup {
    my $self = shift;

    if ( my $groupId = $self->get('subscriptionGroupId') ) {
        return WebGUI::Group->new( $self->session, $groupId );
    }
    else {
        my $group = WebGUI::Group->new($self->session, "new");
        $group->name( "Subscription " . $self->getTitle );
        $group->description( "Subscription Group for " . $self->getTitle . "(" . $self->getId . ")" );
        $group->isEditable( 0 );
        $group->showInForms( 0 );
        $group->deleteGroups( [ "3" ] ); # admins don't want to be auto subscribed to this thing
        $self->update({
            subscriptionGroupId => $group->getId
        });

        return $group;
    }
}

#----------------------------------------------------------------------------
sub isSubscribed {
    my $self    = shift;
    my $user    = shift || $self->session->user;
    my $db      = $self->session->db;

    return $user->isInGroup( $self->getSubscriptionGroup->getId );
    
#    return $db->quickScalar( 'select 1 from NewsletterCollection_subscriptions where assetId=? and userId=?', [ 
#        $self->getId,
#        $userId,
#    ] );
}

#----------------------------------------------------------------------------
sub getSubscriptionForm {
    my $self    = shift;
    my $session = $self->session;
    my $i18n    = WebGUI::International->new( $session, 'Asset_NewsletterCollection' );

    my $formHeader = 
        WebGUI::Form::formHeader( $session, { action => $self->getUrl } )
        . WebGUI::Form::hidden( $session, { name => 'func', value => 'processSubscription' } )
        ;
    my $subscribeButton = 
        sprintf '<button type="submit" name="action" value="subscribe">%s</button>', $i18n->get('subscribe');
    my $unsubscribeButton = 
        sprintf '<button type="submit" name="action" value="unsubscribe">%s</button>', $i18n->get('unsubscribe');
    my $emailBox = WebGUI::Form::email( $session, { name => 'email', value => '' } );
    my $formFooter = WebGUI::Form::formFooter( $session );

    my $output = '';
    if ( $session->user->isRegistered ) {
        $output .= $subscribeButton     if $self->canSubscribe;
        $output .= $unsubscribeButton   if $self->canUnsubscribe;

        return unless $output;
        return $formHeader . $output . $formFooter;
    }
    #### TODO: anonymousAllowed 
    else {
        return $formHeader . $emailBox . $subscribeButton . $unsubscribeButton . $formFooter;
    }

    return;
}

#----------------------------------------------------------------------------
sub getSubscriptionGroup {
    my $self    = shift;
    my $groupId = $self->get( "subscriptionGroupId" );
    my $group   = $groupId 
                ? WebGUI::Group->new( $self->session, $groupId ) 
                : $self->createSubscriptionGroup
                ;

    return $group;
}

#----------------------------------------------------------------------------
sub sendSubscriptionConfirmation {
    my $self    = shift;
    my $user    = shift;
    my $code    = shift;
    my $session = $self->session;

#    my $user    = WebGUI::User->new( $session, $userId );
    my $url     = $session->url->getSiteURL . $self->getUrl( "func=confirmSubscription;code=$code" );

    my $mail = WebGUI::Mail::Send->create( $self->session, {
        to      => $user->get('email'),
        subject => 'Confirm your subscription',
    } );
    $mail->addText( "Click here: $url" );
    $mail->send;

    return;
}


#----------------------------------------------------------------------------
sub subscribe {
    my $self            = shift;
    my $user            = shift || $self->session->user;
    my $requireConfirm  = shift // $self->get('alwaysConfirmSubscription');
    my $session         = $self->session;
    my $db              = $self->session->db;

    if ( $requireConfirm ) {
        my $code = $self->session->id->generate;

        $db->write( 'replace into NewsletterCollection_subscriptions set assetId=?, userId=?, code=?, confirmed=?', [
            $self->getId,
            $user->getId,
            $code,
            0,
        ] );

        $self->sendSubscriptionConfirmation( $user, $code );
    }
    else {
        $self->getSubscriptionGroup->addUsers( [ $user->getId ] );
    }

    return;
}

#----------------------------------------------------------------------------
sub unsubscribe {
    my $self    = shift;
    my $user    = shift || $self->session->user;
#    my $db      = $self->session->db;
    
    $self->getSubscriptionGroup->deleteUsers( [ $user->getId ] );

#    $db->write( 'delete from NewsletterCollection_subscriptions where assetId=? and userId=?', [
#        $self->getId,
#        $user->getId,
#    ] );

    return;
}

#----------------------------------------------------------------------------
sub www_confirmSubscription {
    my $self    = shift;
    my ($form, $db) = $self->session->quick( 'form', 'db' );

    my $code    = $form->get('code');
    return unless $code;

    my $userId = $db->quickScalar( 'select userId from NewsletterCollection_subscriptions where confirmed=? and code=?', [
        0,
        $code,
    ] );
#    $db->write( 'update NewsletterCollection_subscriptions set confirmed=1, code=NULL where code=?', [
#        $code
#    ] );

    if ( $userId ) {
        $self->getSubscriptionGroup->addUsers( [ $userId ] );
    }
    else {
        return $self->processStyle( 'Verkeerde code' );
    }

    return $self->processStyle( 'U bent aangemeld voor deze nieuwsbrief' );
}

#----------------------------------------------------------------------------
sub www_processSubscription {
    my $self    = shift;
    my $session = $self->session;
    my $form    = $session->form;

    my $action  = $form->get( 'action' );
    return unless $action eq 'subscribe' || $action eq 'unsubscribe';

    if ( $session->user->isRegistered ) {
        if ( $action eq 'subscribe' && $self->canSubscribe ) {
            $self->subscribe;
        }
        if ( $action eq 'unsubscribe' && $self->canUnsubscribe ) {
            $self->unsubscribe;
        }
    }
    elsif ( $self->get('allowAnonymousSubscription') ) {
        my $email     = $form->email( 'email' );
        return 'no email' unless $email;

        my $emailUser = WebGUI::User::SpecialState->newByEmail( $session, $email );
        if ( $action eq 'unsubscribe' && defined $emailUser ) {
            $self->unsubscribe( $emailUser );
        }
        if ( $action eq 'subscribe' ) {
            if ( !defined $emailUser ) {
                $emailUser = WebGUI::User::SpecialState->create( $session );
                $emailUser->update( { email => $email } );
            }
            $emailUser->addSpecialState( 'Subscriber', $self->getId );

            $self->subscribe( $emailUser, 1 );
        }
    }
    else {
        return 'anonymous subscription is not allowed.'
    }

    return;
}

#----------------------------------------------------------------------------
sub www_subscribe {
    my $self    = shift;

    if ( $self->canSubscribe ) {
        $self->subscribe;
    }

    return $self->www_view;
}

#----------------------------------------------------------------------------
sub www_unsubscribe {
    my $self    = shift;

    if ( $self->canUnsubscribe ) {
        $self->unsubscribe;
    }

    return $self->www_view;
}

1;