package WebGUI::Asset::Wobject::Gallery;

#-------------------------------------------------------------------
# WebGUI is Copyright 2001-2009 Plain Black Corporation.
#-------------------------------------------------------------------
# Please read the legal notices (docs/legal.txt) and the license
# (docs/license.txt) that came with this distribution before using
# this software.
#-------------------------------------------------------------------
# http://www.plainblack.com                     info@plainblack.com
#-------------------------------------------------------------------

use strict;
#use Class::C3;
#use base qw(WebGUI::AssetAspect::RssFeed WebGUI::Asset::Wobject);
use WebGUI::Definition::Asset;
extends 'WebGUI::Asset::Wobject';
aspect assetName           => ['assetName', 'Asset_Gallery'];
aspect icon                => 'photoGallery.gif';
aspect tableName           => 'Gallery',
property groupIdAddComment => (
            tab             => "security",
            fieldType       => "group",
            default         => 2, # Registered Users
            label           => ["groupIdAddComment label", 'Asset_Gallery'],
            hoverHelp       => ["groupIdAddComment description", 'Asset_Gallery'],
         );
property groupIdAddFile => (
            tab             => "security",
            fieldType       => "group",
            default         => 2, # Registered Users
            label           => ["groupIdAddFile label", 'Asset_Gallery'],
            hoverHelp       => ["groupIdAddFile description", 'Asset_Gallery'],
         );
property imageResolutions => (
            tab             => "properties",
            fieldType       => "checkList",
            builder         => '_imageResolutions_builder',
            lazy            => 1,
            options         => \&_imageResolutions_options,
            label           => ["imageResolutions label", 'Asset_Gallery'],
            hoverHelp       => ["imageResolutions description", 'Asset_Gallery'],
         );
sub _imageResolutions_builder {
    return join("\n", '800', '1024', '1200', '1600', '2880');
}
sub _imageResolutions_options {
    tie my %imageResolutionOptions, 'Tie::IxHash', map { $_ => $_ } qw(600 800 1024 1260 1440 1600 2880);
    return \%imageResolutionOptions;
}
property imageViewSize => (
            tab             => "properties",
            fieldType       => "integer",
            default         => 700,
            label           => ["imageViewSize label", 'Asset_Gallery'],
            hoverHelp       => ["imageViewSize description", 'Asset_Gallery'],
         );
property imageThumbnailSize => (
            tab             => "properties",
            fieldType       => "integer",
            default         => 300,
            label           => ["imageThumbnailSize label", 'Asset_Gallery'],
            hoverHelp       => ["imageThumbnailSize description", 'Asset_Gallery'],
         );
property imageDensity => (
            tab             => "properties",
            fieldType       => "selectBox",
            options         => \&_imageDensity_options,
            default         => 72,
            label           => [ "imageDensity label" , 'Asset_Gallery'],
            hoverHelp       => [ "imageDensity description" , 'Asset_Gallery'],
         );
sub _imageDensity_options {
    my $session = shift->session;
    my $i18n    = WebGUI::International->new($session, 'Asset_Gallery');

    tie my %imageDensityOptions, 'Tie::IxHash', (
        72              => $i18n->get( "imageDensity option web" ),
        300             => $i18n->get( "imageDensity option print" ),
    );
    return \%imageDensityOptions;
}
property maxSpacePerUser => (
            tab             => "properties",
            fieldType       => "integer",
            default         => 0,
            label           => ["maxSpacePerUser label", 'Asset_Gallery'],
            hoverHelp       => ["maxSpacePerUser description", 'Asset_Gallery'],
         );
property richEditIdAlbum => (
            tab             => "properties",
            fieldType       => "selectRichEditor",
            default         => "PBrichedit000000000001", # Content Managers editor
            label           => ["richEditIdAlbum label", 'Asset_Gallery'],
            hoverHelp       => ["richEditIdAlbum description", 'Asset_Gallery'],
         );
property richEditIdFile => (
            tab             => "properties",
            fieldType       => "selectRichEditor",
            default         => "PBrichedit000000000002", # Forum Rich editor
            label           => ["richEditIdFile label", 'Asset_Gallery'],
            hoverHelp       => ["richEditIdFile description", 'Asset_Gallery'],
         );
property richEditIdComment => (
            tab             => "properties",
            fieldType       => "selectRichEditor",
            default         => "PBrichedit000000000002", # Forum Rich Editor
            label           => ["richEditIdFileComment label", 'Asset_Gallery'],
            hoverHelp       => ["richEditIdFileComment description", 'Asset_Gallery'],
         );
property templateIdAddArchive => (
            tab             => "display",
            fieldType       => "template",
            default         => "i0X4Q3tBWUb_thsVbsYz9xQ",
            namespace       => "GalleryAlbum/AddArchive",
            label           => ["templateIdAddArchive label", 'Asset_Gallery'],
            hoverHelp       => ["templateIdAddArchive description", 'Asset_Gallery'],
         );
property templateIdDeleteAlbum => (
            tab             => "display",
            fieldType       => "template",
            default         => "UTNFeV7B_aSCRmmaFCq4Vw",
            namespace       => "GalleryAlbum/Delete",
            label           => ["templateIdDeleteAlbum label", 'Asset_Gallery'],
            hoverHelp       => ["templateIdDeleteAlbum description", 'Asset_Gallery'],
         );
property templateIdDeleteFile => (
            tab             => "display",
            fieldType       => "template",
            default         => "zcX-wIUct0S_np14xxOA-A",
            namespace       => "GalleryFile/Delete",
            label           => ["templateIdDeleteFile label", 'Asset_Gallery'],
            hoverHelp       => ["templateIdDeleteFile description", 'Asset_Gallery'],
         );
property templateIdEditAlbum => (
            tab             => "display",
            fieldType       => "template",
            default         => "6X-7Twabn5KKO_AbgK3PEw",
            namespace       => "GalleryAlbum/Edit",
            label           => ["templateIdEditAlbum label", 'Asset_Gallery'],
            hoverHelp       => ["templateIdEditAlbum description", 'Asset_Gallery'],
         );
property templateIdEditComment => (
            tab             => "display",
            fieldType       => "template",
            default         => "OxJWQgnGsgyGohP2L3zJPQ",
            namespace       => "GalleryFile/EditComment",
            label           => ["templateIdEditComment label", 'Asset_Gallery'],
            hoverHelp       => ["templateIdEditComment description", 'Asset_Gallery'],
         );
property templateIdEditFile => (
            tab             => "display",
            fieldType       => "template",
            default         => "7JCTAiu1U_bT9ldr655Blw",
            namespace       => "GalleryFile/Edit",
            label           => ["templateIdEditFile label", 'Asset_Gallery'],
            hoverHelp       => ["templateIdEditFile description", 'Asset_Gallery'],
         );
property templateIdListAlbums => (
            tab             => "display",
            fieldType       => "template",
            default         => "azCqD0IjdQSlM3ar29k5Sg",
            namespace       => "Gallery/ListAlbums",
            label           => ["templateIdListAlbums label", 'Asset_Gallery'],
            hoverHelp       => ["templateIdListAlbums description", 'Asset_Gallery'],
         );
property templateIdListAlbumsRss => (
            tab             => "display",
            fieldType       => "template",
            default         => "ilu5BrM-VGaOsec9Lm7M6Q",
            namespace       => "Gallery/ListAlbumsRss",
            label           => ["templateIdListAlbumsRss label", 'Asset_Gallery'],
            hoverHelp       => ["templateIdListAlbumsRss description", 'Asset_Gallery'],
         );
property templateIdListFilesForUser => (
            tab             => "display",
            fieldType       => "template",
            default         => "OkphOEdaSGTXnFGhK4GT5A",
            namespace       => "Gallery/ListFilesForUser",
            label           => ["templateIdListFilesForUser label", 'Asset_Gallery'],
            hoverHelp       => ["templateIdListFilesForUser description", 'Asset_Gallery'],
         );
property templateIdListFilesForUserRss => (
            tab             => "display",
            fieldType       => "template",
            default         => "-ANLpoTEP-n4POAdRxCzRw",
            namespace       => "Gallery/ListFilesForUserRss",
            label           => ["templateIdListFilesForUserRss label", 'Asset_Gallery'],
            hoverHelp       => ["templateIdListFilesForUserRss description", 'Asset_Gallery'],
         );
property templateIdMakeShortcut => (
            tab             => "display",
            fieldType       => "template",
            default         => "m3IbBavqzuKDd2PGGhKPlA",
            namespace       => "GalleryFile/MakeShortcut",
            label           => ["templateIdMakeShortcut label", 'Asset_Gallery'],
            hoverHelp       => ["templateIdMakeShortcut description", 'Asset_Gallery'],
         );
property templateIdSearch => (
            tab             => "display",
            fieldType       => "template",
            default         => "jME5BEDYVDlBZ8jIQA9-jQ",
            namespace       => "Gallery/Search",
            label           => ["templateIdSearch label", 'Asset_Gallery'],
            hoverHelp       => ["templateIdSearch description", 'Asset_Gallery'],
         );
property templateIdViewSlideshow => (
            tab             => "display",
            fieldType       => "template",
            default         => "KAMdiUdJykjN02CPHpyZOw",
            namespace       => "GalleryAlbum/ViewSlideshow",
            label           => ["templateIdViewSlideshow label", 'Asset_Gallery'],
            hoverHelp       => ["templateIdViewSlideshow description", 'Asset_Gallery'],
         );
property templateIdViewThumbnails => (
            tab             => "display",
            fieldType       => "template",
            default         => "q5O62aH4pjUXsrQR3Pq4lw",
            namespace       => "GalleryAlbum/ViewThumbnails",
            label           => ["templateIdViewThumbnails label", 'Asset_Gallery'],
            hoverHelp       => ["templateIdViewThumbnails description", 'Asset_Gallery'],
         );
property templateIdViewAlbum => (
            tab             => "display",
            fieldType       => "template",
            default         => "05FpjceLYhq4csF1Kww1KQ",
            namespace       => "GalleryAlbum/View",
            label           => ["templateIdViewAlbum label", 'Asset_Gallery'],
            hoverHelp       => ["templateIdViewAlbum description", 'Asset_Gallery'],
         );
property templateIdViewAlbumRss => (
            tab             => "display",
            fieldType       => "template",
            default         => "mM3bjP_iG9sv5nQb4S17tQ",
            namespace       => "GalleryAlbum/ViewRss",
            label           => ["templateIdViewAlbumRss label", 'Asset_Gallery'],
            hoverHelp       => ["templateIdViewAlbumRss description", 'Asset_Gallery'],
         );
property templateIdViewFile => (
            tab             => "display",
            fieldType       => "template",
            default         => "TEId5V-jEvUULsZA0wuRuA",
            namespace       => "GalleryFile/View",
            label           => ["templateIdViewFile label", 'Asset_Gallery'],
            hoverHelp       => ["templateIdViewFile description", 'Asset_Gallery'],
         );
property viewDefault => (
            tab             => "display",
            fieldType       => "selectBox",
            default         => "list",
            options         => \&_viewDefault_options,
            label           => ["viewDefault label", 'Asset_Gallery'],
            hoverHelp       => ["viewDefault description", 'Asset_Gallery'],
         );
sub _viewDefault_options {
    my $session = shift->session;
    my $i18n    = WebGUI::International->new($session, 'Asset_Gallery');
    tie my %viewDefaultOptions, 'Tie::IxHash', (
        list        => $i18n->get("viewDefault option list"),
        album       => $i18n->get("viewDefault option album"),
    );
    return \%viewDefaultOptions;
}
property viewAlbumAssetId => (
            tab             => "display",
            fieldType       => "asset",
            class           => "WebGUI::Asset::Wobject::GalleryAlbum",
            label           => ["viewAlbumAssetId label", 'Asset_Gallery'],
            hoverHelp       => ["viewAlbumAssetId description", 'Asset_Gallery'],
         );
property viewListOrderBy => (
            tab             => "display",
            fieldType       => "selectBox",
            default         => "lineage", # "Sequence Number"
            options         => \&_viewListOrderBy_options,
            label           => ["viewListOrderBy label", 'Asset_Gallery'],
            hoverHelp       => ["viewListOrderBy description", 'Asset_Gallery'],
         );
sub _viewListOrderBy_options {
    my $session = shift->session;
    my $i18n    = WebGUI::International->new($session, 'Asset_Gallery');

    tie my %viewListOrderByOptions, 'Tie::IxHash', (
        creationDate    => $i18n->get("viewListOrderBy option creationDate"),
        lineage         => $i18n->get("viewListOrderBy option lineage"),
        revisionDate    => $i18n->get("viewListOrderBy option revisionDate"),
        title           => $i18n->get("viewListOrderBy option title"),
    );
    return \%viewListOrderByOptions;
    
}
property viewListOrderDirection => (
            tab             => "display",
            fieldType       => "selectBox",
            default         => "ASC",
            options         => \&_viewListOrderDirection_options,
            label           => ["viewListOrderDirection label", 'Asset_Gallery'],
            hoverHelp       => ["viewListOrderDirection description", 'Asset_Gallery'],
         );
sub _viewListOrderDirection_options {
    my $session = shift->session;
    my $i18n    = WebGUI::International->new($session, 'Asset_Gallery');
    tie my %viewListOrderDirectionOptions, 'Tie::IxHash', (
        ASC             => $i18n->get("viewListOrderDirection option asc"),
        DESC            => $i18n->get("viewListOrderDirection option desc"),
    );
    return \%viewListOrderDirectionOptions;
}
property workflowIdCommit => (
            tab             => "security",
            fieldType       => "workflow",
            default         => "pbworkflow000000000003", # Commit without approval
            type            => 'WebGUI::VersionTag',
            label           => ["workflowIdCommit label", 'Asset_Gallery'],
            hoverHelp       => ["workflowIdCommit description", 'Asset_Gallery'],
         );
property defaultFilesPerPage => (
            tab             => 'display',
            fieldType       => 'integer',
            default         => 24,
            label           => [ 'defaultFilesPerPage label' , 'Asset_Gallery'],
            hoverHelp       => [ 'defaultFilesPerPage description' , 'Asset_Gallery'],
         );



use JSON;
use Tie::IxHash;
use WebGUI::International;
use WebGUI::Utility;
use XML::Simple;
use WebGUI::HTML;

=head1 NAME

=head1 DESCRIPTION

=head1 SYNOPSIS

=head1 DIAGNOSTICS

=head1 METHODS

#----------------------------------------------------------------------------

=head2 addChild ( properties, [...] )

Add a child to this asset. See C<WebGUI::AssetLineage> for more info.

Overridden to ensure that only GalleryAlbums are added to Galleries.

=cut

sub addChild {
    my $self        = shift;
    my $properties  = shift;
    my $albumClass  = "WebGUI::Asset::Wobject::GalleryAlbum";

    # Load the class
    WebGUI::Pluggable::load( $properties->{className} );

    if ( !$properties->{className}->isa( $albumClass ) ) {
        $self->session->errorHandler->security(
            "add a ".$properties->{className}." to a ".$self->className
        );
        return undef;
    }

    return $self->next::method( $properties, @_ );
}

#----------------------------------------------------------------------------

=head2 appendTemplateVarsSearchForm ( var )

Appends the template vars for the search form to the hash reference C<var>.
Returns the hash reference for convenience.

=cut

sub appendTemplateVarsSearchForm {
    my $self        = shift;
    my $var         = shift;
    my $session     = $self->session;
    my $form        = $self->session->form;
    my $i18n        = WebGUI::International->new($session, 'Asset_Gallery');

    $var->{ searchForm_start    } 
        = WebGUI::Form::formHeader( $session, {
            action      => $self->getUrl('func=search'),
            method      => "GET",
        });

    $var->{ searchForm_end      } 
        = WebGUI::Form::formFooter( $session );

    $var->{ searchForm_basicSearch }
        = WebGUI::Form::text( $session, {
            name        => "basicSearch",
            value       => $form->get("basicSearch"),
        });

    $var->{ searchForm_title    }
        = WebGUI::Form::text( $session, {
            name        => "title",
            value       => $form->get("title"),
        });

    $var->{ searchForm_description }
        = WebGUI::Form::text( $session, {
            name        => "description",
            value       => $form->get("description"),
        });

    $var->{ searchForm_keywords }
        = WebGUI::Form::text( $session, {
            name        => "keywords",
            value       => $form->get("keywords"),
        });

    # Search classes
    tie my %searchClassOptions, 'Tie::IxHash', (
        'WebGUI::Asset::File::GalleryFile::Photo'   => $i18n->get("search class photo"),
        'WebGUI::Asset::Wobject::GalleryAlbum'      => $i18n->get("search class galleryalbum"),
        ''                                          => $i18n->get("search class any"),
    );
    $var->{ searchForm_className }
        = WebGUI::Form::radioList( $session, {
            name        => "className",
            value       => ( $form->get("className") || '' ),
            options     => \%searchClassOptions,
        });

    # Search creationDate
    my $oneYearAgo      = WebGUI::DateTime->new( $session, time )->add( years => -1 )->epoch;
    $var->{ searchForm_creationDate_after }
        = WebGUI::Form::dateTime( $session, {
            name        => "creationDate_after",
            value       => $form->get("creationDate_after",  "dateTime", $oneYearAgo),
        });
    $var->{ searchForm_creationDate_before }
        = WebGUI::Form::dateTime( $session, {
            name        => "creationDate_before",
            value       => $form->get("creationDate_before", "dateTime", time()),
        });

    # Buttons
    $var->{ searchForm_submit }
        = WebGUI::Form::submit( $session, {
            name        => "submit",
            value       => $i18n->get("search submit"),
        });

    return $var;
}

#----------------------------------------------------------------------------

=head2 canAddFile ( [userId] )

Returns true if the user can add files to this Gallery. C<userId> is the 
userId to check. If no userId is passed, will check the current user.

Users can add files to this gallery if they are part of the C<groupIdAddFile>

=cut

sub canAddFile {
    my $self        = shift;
    my $userId      = shift;

    my $user        = $userId
                    ? WebGUI::User->new( $self->session, $userId )
                    : $self->session->user
                    ;

    return $user->isInGroup( $self->groupIdAddFile );
}

#----------------------------------------------------------------------------

=head2 canComment ( [userId] )

Returns true if the user can comment on this Gallery. C<userId> is the userId
to check. If no userId is passed, will check the current user.

Users can comment on this gallery if they are part of the 
C<groupIdAddComment> group.

=cut

sub canComment {
    my $self        = shift;
    my $userId      = shift;

    my $user        = $userId
                    ? WebGUI::User->new( $self->session, $userId )
                    : $self->session->user
                    ;

    return $user->isInGroup( $self->groupIdAddComment );
}

#----------------------------------------------------------------------------

=head2 canEdit ( [userId] )

Returns true if the user can edit this Gallery. C<userId> is the userId to 
check. If no userId is passed, will check the current user.

Users can edit this gallery if they are part of the C<groupIdEdit> group.

Also checks if a user is adding a GalleryAlbum and allows them to if they are
part of the C<groupIdAddFile> group.

=cut

sub canEdit {
    my $self        = shift;
    my $userId      = shift;

    my $form        = $self->session->form;

    if ( $form->get('func') eq "add" && $form->get( 'class' )->isa( "WebGUI::Asset::Wobject::GalleryAlbum" ) ) {
        return $self->canAddFile( $userId );
    }
    elsif ( $form->get('func') eq "editSave" && $form->get('assetId') eq "new" && $form->get( 'class' )->isa( 'WebGUI::Asset::Wobject::GalleryAlbum' ) ) {
        return $self->canAddFile( $userId );
    }
    else {
        my $user        = $userId
                        ? WebGUI::User->new( $self->session, $userId )
                        : $self->session->user
                        ;

        return $user->isInGroup( $self->groupIdEdit );
    }
}

#----------------------------------------------------------------------------

=head2 canView ( [userId] )

Returns true if the user can view this Gallery. C<userId> is the userId to 
check. If no userId is passed, will check the current user.

Users can view this gallery if they are part of the C<groupIdView> group.

=cut

sub canView {
    my $self        = shift;
    my $userId      = shift;

    my $user        = $userId
                    ? WebGUI::User->new( $self->session, $userId )
                    : $self->session->user
                    ;

    return $user->isInGroup( $self->groupIdView );
}

#----------------------------------------------------------------------------

=head2 getAlbumIds ( options )

Gets an array reference of all the album IDs under this Gallery. C<options> 
is a hash reference with the following keys.

 orderBy            => An SQL ORDER BY clause to sort the albums. 
                    By default, uses the viewListOrderBy and viewListOrderDirection keys from
                    the asset properties.

=cut

sub getAlbumIds {
    my $self        = shift;
    my $options     = shift;

    my $orderBy     = $options->{ orderBy }
                    ? $options->{ orderBy }
                    : $self->viewListOrderBy
                    ? join( " ", $self->getviewListOrderBy, $self->viewListOrderDirection )
                    : "lineage ASC"
                    ;

    # Deal with "pending" albums.
    my %pendingRules;
    if ( $self->canEdit ) {
        $pendingRules{ statusToInclude } = [ 'pending', 'approved' ];
    }
    else {
        $pendingRules{ statusToInclude } = [ 'pending', 'approved' ];
        $pendingRules{ whereClause } = q{
            ( 
                status = "approved" || ownerUserId = "} . $self->session->user->userId . q{"
            )
        };
    }

    my $assets 
        = $self->getLineage(['descendants'], {
            includeOnlyClasses  => ['WebGUI::Asset::Wobject::GalleryAlbum'],
            orderByClause       => $orderBy,
            ( %pendingRules ),
        });

    return $assets;
}

#----------------------------------------------------------------------------

=head2 getAlbumPaginator ( options )

Gets a WebGUI::Paginator for all the albums in this Gallery. C<options> is a
hash reference with the following keys.

 perpage            => The number of results to show per page. Default: 20

For more C<options>, see L</getAlbumIds>.

=cut

sub getAlbumPaginator {
    my $self        = shift;
    my $options     = shift;

    my $perpage     = $options->{ perpage }      || 20;
    delete $options->{ perpage };

    my $p
        = WebGUI::Paginator->new( $self->session, $self->getUrl, $perpage );
    $p->setDataByArrayRef( $self->getAlbumIds( $options ) );

    return $p;
}

#----------------------------------------------------------------------------

=head2 getAssetClassForFile ( filepath )

Gets the WebGUI Asset class for the file at the given C<filepath>. Returns
undef if the file cannot be saved under this Gallery.

=cut

sub getAssetClassForFile {
    my $self        = shift;
    my $filepath    = shift;

    $self->session->log->info( "Checking asset class for file '$filepath'" );

    # Checks for Photo assets
    if ( $filepath =~ /\.(jpe?g|gif|png)$/i ) {
        return "WebGUI::Asset::File::GalleryFile::Photo";
    }

    # No class found
    return undef;
}

#----------------------------------------------------------------------------

=head2 getGalleryFileClassesAvailable ( )

Returns an array reference of the Asset classes available to be added to this
Gallery.

=cut

sub getGalleryFileClassesAvailable {
    my $self        = shift;

    return [ 'WebGUI::Asset::File::GalleryFile::Photo' ];
}

#----------------------------------------------------------------------------

=head2 getImageResolutions ( )

Gets an array reference of the image resolutions to create for image-type
assets in this gallery.

=cut

sub getImageResolutions {
    my $self        = shift;
    return [ split /\n/, $self->imageResolutions ];
}

#----------------------------------------------------------------------------

=head2 getNextAlbumId ( albumId )

Gets the next albumId from the list of albumIds. C<albumId> is the base 
albumId we want to find the next album for.

Returns C<undef> if there is no next albumId.

=cut

sub getNextAlbumId {
    my $self        = shift;
    my $albumId     = shift;
    my $allAlbumIds = $self->getAlbumIds;

    while ( my $checkId = shift @{ $allAlbumIds } ) {
        # If this is the last albumId
        return undef unless @{ $allAlbumIds };

        if ( $albumId eq $checkId ) {
            return shift @{ $allAlbumIds };
        }
    }
}

#----------------------------------------------------------------------------

=head2 getPreviousAlbumId ( albumId )

Gets the previous albumId from the list of albumIds. C<albumId> is the base 
albumId we want to find the previous album for.

Returns C<undef> if there is no previous albumId.

=cut

sub getPreviousAlbumId {
    my $self        = shift;
    my $albumId     = shift;
    my $allAlbumIds = $self->getAlbumIds; 

    while ( my $checkId = pop @{ $allAlbumIds } ) {
        # If this is the last albumId
        return undef unless @{ $allAlbumIds };

        if ( $albumId eq $checkId ) {
            return pop @{ $allAlbumIds };
        }
    }
}

#-------------------------------------------------------------------

=head2 getRssFeedItems ()

Returns an array reference of hash references. Each hash reference has a title,
description, link, and date field. The date field can be either an epoch date, an RFC 1123
date, or a ISO date in the format of YYYY-MM-DD HH:MM::SS. Optionally specify an
author, and a guid field.

=cut

sub getRssFeedItems {
    my $self        = shift;

    my $p
        = $self->getAlbumPaginator( { 
            perpage     => $self->itemsPerFeed,
        } );

    my $var = [];
    for my $assetId ( @{ $p->getPageData } ) {
        my $asset       = WebGUI::Asset::Wobject::GalleryAlbum->newPending( $self->session, $assetId );
        push @{ $var }, {
            'link'          => $asset->getUrl,
            'guid'          => $asset->{_properties}->{ 'assetId' },
            'title'         => $asset->getTitle,
            'description'   => $asset->{_properties}->{ 'description' },
            'date'          => $asset->{_properties}->{ 'creationDate' },
            'author'        => WebGUI::User->new($self->session, $asset->{_properties}->{ 'ownerUserId' })->username
        };
    }

    return $var;
}

#----------------------------------------------------------------------------

=head2 getSearchPaginator ( rules )

Gets a WebGUI::Paginator for a search. C<rules> is a hash reference of 
options with the following keys:

    keywords       => Keywords to search on 

Other keys are valid, see C<WebGUI::Search::search()> for details.

=cut

sub getSearchPaginator {
    my $self        = shift;
    my $rules       = shift;

    $rules->{ lineage       } = [ $self->lineage ];

    my $search      = WebGUI::Search->new( $self->session );
    $search->search( $rules );
    my $paginator   = $search->getPaginatorResultSet( $rules->{url} );

    return $paginator;
}

#----------------------------------------------------------------------------

=head2 getTemplateIdEditFile ( )

Returns the ID for the template to edit a file.

NOTE: This may need to change in the future to take into account different
classes of files inside of a Gallery.

=cut

sub getTemplateIdEditFile {
    my $self        = shift;
    return $self->templateIdEditFile;
}

#----------------------------------------------------------------------------

=head2 getTemplateVars ( )

Gets a hash reference of vars common to all templates.

=cut

sub getTemplateVars {
    my $self        = shift;
    my $var         = $self->get;

    # Add the search form variables
    $self->appendTemplateVarsSearchForm( $var );

    $var->{ url                         } = $self->getUrl;
    $var->{ url_addAlbum                } = $self->getUrl('func=add;class=WebGUI::Asset::Wobject::GalleryAlbum');
    $var->{ url_listAlbums              } = $self->getUrl('func=listAlbums');
    $var->{ url_listAlbumsRss           } = $self->getUrl('func=listAlbumsRss');
    $var->{ url_listFilesForCurrentUser } = $self->getUrl('func=listFilesForUser');
    $var->{ url_search                  } = $self->getUrl('func=search');

    $var->{ canEdit             } = $self->canEdit;
    $var->{ canAddFile          } = $self->canAddFile;

    return $var;
}

#----------------------------------------------------------------------------

=head2 getUserAlbumIds ( [userId] )

Gets an array reference of assetIds for the GalleryAlbums in this Gallery 
owned by the specified C<userId>. If userId is not defined, will use the 
current user.

=cut

sub getUserAlbumIds {
    my $self        = shift;
    my $userId      = shift || $self->session->user->userId;

    my $db          = $self->session->db;

    my $assetIds
        = $self->getLineage( ['descendants'], {
            includeOnlyClasses  => [ 'WebGUI::Asset::Wobject::GalleryAlbum' ],
            whereClause         => "ownerUserId = " . $db->quote($userId),
        });

    return $assetIds;
}

#----------------------------------------------------------------------------

=head2 getUserFileIds ( [userId] )

Gets an array reference of assetIds for the files in this Gallery owned by 
the specified C<userId>. If userId is not defined, will use the current user.

=cut

sub getUserFileIds {
    my $self        = shift;
    my $userId      = shift || $self->session->user->userId;

    my $db          = $self->session->db;

    # Note: We use excludeClasses to avoid getting GalleryAlbum assets
    my $assetIds
        = $self->getLineage( ['descendants'], {
            excludeClasses      => [ 'WebGUI::Asset::Wobject::GalleryAlbum' ],
            whereClause         => "ownerUserId = " . $db->quote($userId),
        });

    return $assetIds;
}

#----------------------------------------------------------------------------

=head2 getUserFilePaginator ( options )

Gets a WebGUI::Paginator for the files owned by a specific C<userId>. 
C<options> is a hash reference of options with the following keys:

 userId         => The user who owns the asset. Defaults to the current user.
 url            => The URL to give to the paginator

=cut

sub getUserFilePaginator {
    my $self        = shift;
    my $options     = shift;
    my $userId      = delete $options->{userId};
    my $url         = delete $options->{url};

    my $p           = WebGUI::Paginator->new( $self->session, $url );
    $p->setDataByArrayRef( $self->getUserFileIds( $userId ) );

    return $p;
}

#----------------------------------------------------------------------------

=head2 hasSpaceAvailable ( spaceWanted [, userId ] )

Returns true if the user has at least the specified bytes of C<spaceWanted>
available to use in this Gallery.

=cut

sub hasSpaceAvailable {
    my $self        = shift;
    my $spaceWanted = shift;
    my $userId      = shift || $self->session->user->userId;

    # If we don't care, just return
    return 1 if ( $self->maxSpacePerUser == 0 );

    my $db          = $self->session->db;

    # Compile the amount of disk space used
    my $maxSpace    = $self->maxSpacePerUser * ( 1_024 ** 2 ); # maxSpacePerUser is in MB
    my $spaceUsed   = 0;
    my $fileIds
        = $self->getLineage( [ 'descendants' ], { 
            joinClass       => 'WebGUI::Asset::File::GalleryFile',
            whereClause     => 'ownerUserId = ' . $db->quote( $userId ),
        } );

    for my $assetId ( @{ $fileIds } ) {
        my $asset       = WebGUI::Asset->newById( $self->session, $assetId );
        next unless $asset;
        $spaceUsed += $asset->assetSize;

        return 0 if ( $spaceUsed + $spaceWanted >= $maxSpace );
    }

    # We must have enough space
    return 1;
}

#----------------------------------------------------------------------------

=head2 prepareView ( )

See WebGUI::Asset::prepareView() for details.

=cut

sub prepareView {
    my $self = shift;
    $self->next::method();

    if ( $self->viewDefault eq "album" && $self->viewAlbumAssetId && $self->viewAlbumAssetId ne 'PBasset000000000000001') {
        my $asset
            = WebGUI::Asset->newById( $self->session, $self->viewAlbumAssetId );
        if ($asset) {
            $asset->prepareView;
            $self->{_viewAsset} = $asset;
        }
        else {
            $self->prepareViewListAlbums;
        }
    }
    else {
        $self->prepareViewListAlbums;
    }
}

#----------------------------------------------------------------------------

=head2 prepareViewListAlbums ( )

Prepare the template for listing multiple albums.

=cut

sub prepareViewListAlbums {
    my $self        = shift;
    my $template 
        = WebGUI::Asset::Template->new($self->session, $self->templateIdListAlbums);
    if (!$template) {
        WebGUI::Error::ObjectNotFound::Template->throw(
            error      => qq{Template not found},
            templateId => $self->templateIdListAlbums,
            assetId    => $self->getId,
        );
    }
    $template->prepare($self->getMetaDataAsTemplateVariables);
    $self->{_viewTemplate} = $template;
}

#----------------------------------------------------------------------------

=head2 view ( )

Show the default view based on the Gallery settings.

=cut

sub view {
    my $self    = shift;
    my $session = $self->session;	
    my $var     = $self->get;

    if ( $self->viewDefault eq "album" && $self->{_viewAsset}) {
        return $self->{_viewAsset}->view;
    }
    else {
        return $self->view_listAlbums;
    }
}

#----------------------------------------------------------------------------

=head2 view_listAlbums ( )

Show a paginated list of the albums in this gallery. This method does the 
actual work.

=cut

sub view_listAlbums {
    my $self        = shift;
    my $session     = $self->session;
    my $var         = $self->getTemplateVars;
    my $form        = $self->session->form;

    my $p
        = $self->getAlbumPaginator( { 
            perpage     => ( $form->get('perpage') || 20 ),
        } );
    $p->appendTemplateVars( $var );

    for my $assetId ( @{ $p->getPageData } ) {
        my $asset       = WebGUI::Asset::Wobject::GalleryAlbum->newPending( $session, $assetId );
        push @{ $var->{albums} }, $asset->getTemplateVars;
    }

    return $self->processTemplate( $var, undef, $self->{_viewTemplate} );
}

#----------------------------------------------------------------------------

=head2 www_add ( )

Add a GalleryAlbum to this Gallery. Overridden here to show an error message
if the Gallery is not committed.

If a GalleryAlbum is added to an uncommitted Gallery, and the GalleryAlbum
is committed before the Gallery, problems start happening.

TODO: This could be handled better by the requestAutoCommit subroutine 
instead of having to block things from being added.

=cut

sub www_add {
    my $self        = shift;

    unless ( $self->hasBeenCommitted ) {
        my $i18n    = WebGUI::International->new($self->session, 'Asset_Gallery');
        return $self->processStyle($i18n->get("error add uncommitted"));
    }

    return $self->next::method( @_ );
}

#----------------------------------------------------------------------------

=head2 www_addAlbumService ( )

A web service to create albums. Returns a json string that looks like this:

    {
       "lastUpdated" : "2008-10-13 17:31:32",
       "canAddFiles" : 1,
       "url" : "http://dev.localhost.localdomain/cool-gallery/the-cool-album2",
       "title" : "The Cool Album",
       "dateCreated" : "2008-10-13 17:31:32"
    }

You can make the request as a post to the gallery url with the following variables:

=head3 func

Required. Must have a value of "addAlbumService"

=head3 as

Defaults to 'json', but if specified as 'xml' then the return result will be:

    <opt>
      <canAddFiles>1</canAddFiles>
      <dateCreated>2008-10-13 17:39:22</dateCreated>
      <lastUpdated>2008-10-13 17:39:22</lastUpdated>
      <title>The Cool Album</title>
      <url>http://dev.localhost.localdomain/cool-gallery/the-cool-album3</url>
    </opt>

=head3 title

The title of the album you wish to create.

=head3 synopsis

A brief description of the album you wish to create.

=head3 othersCanAdd

A 1 or a 0 depending on whether you want other people to be able to add images to this album.

=cut

sub www_addAlbumService {
    my $self        = shift;
    my $session     = $self->session;

    return $session->privilege->insufficient unless ($self->canAddFile);
    my $form = $session->form;

    my $album = $self->addChild({
        className       => "WebGUI::Asset::Wobject::GalleryAlbum",
        title           => $form->get('title','text'),
        description     => $form->get('synopsis','textarea'),
        synopsis        => $form->get('synopsis','textarea'),
        othersCanAdd    => $form->get('othersCanAdd','yesNo'),
        ownerUserId     => $session->user->userId,
    });

    $album->requestAutoCommit;

    my $siteUrl = $session->url->getSiteURL;
    my $date = $session->datetime;
    my $as = $form->get('as') || 'json';

    my $document = {
        canAddFiles     => $album->canAddFile,
        title           => $album->getTitle,
        url             => $siteUrl.$album->getUrl,
        dateCreated     => $date->epochToHuman($album->creationDate, '%y-%m-%d %j:%n:%s'),
        lastUpdated     => $date->epochToHuman($album->revisionDate, '%y-%m-%d %j:%n:%s'),
    };
    if ($as eq "xml") {
        $session->http->setMimeType('text/xml');
        return XML::Simple::XMLout($document, NoAttr => 1);
    }

    $session->http->setMimeType('application/json');
    return JSON->new->pretty->encode($document);
}

#----------------------------------------------------------------------------

=head2 www_listAlbums ( )

Show a paginated list of the albums in this gallery.

=cut

sub www_listAlbums {
    my $self        = shift;

    # Perform the prepareView ourselves
    $self->prepareViewListAlbums;

    return $self->processStyle(
        $self->view_listAlbums
    );
}

#----------------------------------------------------------------------------

=head2 www_listAlbumsRss ( )

Show an RSS feed for the albums in this gallery.

=cut

sub www_listAlbumsRss {
    my $self        = shift;
    my $session     = $self->session;
    my $var         = $self->getTemplateVars;

    for my $assetId ( @{ $self->getAlbumIds } ) {
        my $asset       = WebGUI::Asset->new( $session, $assetId, 'WebGUI::Asset::Wobject::GalleryAlbum');
        my $assetVar    = $asset->getTemplateVars;

        # Fix URLs
        for my $key ( qw( url ) ) {
            $assetVar->{ $key } = $self->session->url->getSiteURL . $assetVar->{ $key };
        }

        # Encode XML entities
        for my $key ( qw( title description synopsis gallery_title gallery_menuTitle ) ) {
            $assetVar->{ $key } = WebGUI::HTML::filter($assetVar->{$key}, 'xml');
        }

        # Additional vars for RSS
        $assetVar->{ rssDate  } 
            = $session->datetime->epochToMail( $assetVar->{ creationDate } );

        push @{ $var->{albums} }, $assetVar;
    }

    $self->session->http->setMimeType('text/xml');
    return $self->processTemplate( $var, $self->templateIdListAlbumsRss );
}

#----------------------------------------------------------------------------

=head2 www_listAlbumsService ( )

A web service to retrieve album information. You may request information from this gallery with a straight GET request:

http://admin:123qwe@www.example.com/gallery-url?func=listAlbumsService

The following parameters are optional, but may be passed along the query to change the output of this method.

=head3 as

Defaults to 'json', but can be overridden as 'xml'. If specified as 'json' the document returned will look like this:

    {
       "pageNumber" : 1,
       "gallery" : {
          "lastUpdated" : "2008-10-13 14:56:49",
          "synopsis" : "This is the summary.",
          "menuTitle" : "My Cool Gallery",
          "url" : "http://dev.localhost.localdomain/cool-gallery",
          "title" : "My Cool Gallery",
          "canAddAlbums" : 1,
          "dateCreated" : "2008-10-13 14:48:44"
       },
       "albums" : [
          {
             "thumbnailUrl" : "http://dev.localhost.localdomain",
             "lastUpdated" : "2008-10-13 14:51:38",
             "canAddFiles" : 1,
             "url" : "http://dev.localhost.localdomain/cool-gallery/the-gallery-you-can-post-to",
             "title" : "The Gallery You Can Post To",
             "dateCreated" : "2008-10-13 14:50:22"
          },
          {
             "thumbnailUrl" : "http://dev.localhost.localdomain",
             "lastUpdated" : "2008-10-13 14:51:20",
             "canAddFiles" : 0,
             "url" : "http://dev.localhost.localdomain/cool-gallery/another-album",
             "title" : "Another Album",
             "dateCreated" : "2008-10-13 14:51:20"
          }
       ]
    }

If specified as 'xml' the document returned will look like this:

    <opt>
      <albums>
        <canAddFiles>1</canAddFiles>
        <dateCreated>2008-10-13 14:50:22</dateCreated>
        <lastUpdated>2008-10-13 14:51:38</lastUpdated>
        <thumbnailUrl>http://dev.localhost.localdomain</thumbnailUrl>
        <title>The Gallery You Can Post To</title>
        <url>http://dev.localhost.localdomain/cool-gallery/the-gallery-you-can-post-to</url>
      </albums>
      <albums>
        <canAddFiles>0</canAddFiles>
        <dateCreated>2008-10-13 14:51:20</dateCreated>
        <lastUpdated>2008-10-13 14:51:20</lastUpdated>
        <thumbnailUrl>http://dev.localhost.localdomain</thumbnailUrl>
        <title>Another Album</title>
        <url>http://dev.localhost.localdomain/cool-gallery/another-album</url>
      </albums>
      <gallery>
        <canAddAlbums>1</canAddAlbums>
        <dateCreated>2008-10-13 14:48:44</dateCreated>
        <lastUpdated>2008-10-13 14:56:49</lastUpdated>
        <menuTitle>My Cool Gallery</menuTitle>
        <synopsis>This is the summary.</synopsis>
        <title>My Cool Gallery</title>
        <url>http://dev.localhost.localdomain/cool-gallery</url>
      </gallery>
      <pageNumber>1</pageNumber>
    </opt>

=head3 pn

Defaults to 1. This represents the page number. It will return up to 100 albums at a time.

=cut

sub www_listAlbumsService {
    my $self        = shift;
    my $session     = $self->session;

    return $session->privilege->insufficient unless ($self->canView);

    my $siteUrl = $session->url->getSiteURL;
    my @assets;
    my $date = $session->datetime;
    my $form = $session->form;
    my $as = $form->get('as') || 'json';
    my $pageNumber = $form->get('pn') || 1;
    my $user = $session->user;
    my $count = 1;

    for my $assetId ( @{ $self->getAlbumIds } ) {
        if ($count < $pageNumber * 100 - 100) { # skip low page numbers
            next;
        }
        if ($count > $pageNumber * 100 - 1) { # skip high page numbers
            last;
        }        
        my $asset       = WebGUI::Asset->new( $session, $assetId, 'WebGUI::Asset::Wobject::GalleryAlbum' );
        if (defined $asset) {
            if ($asset->canView) {
                push @assets, {
                    title           => $asset->getTitle,
                    url             => $siteUrl.$asset->getUrl,
                    dateCreated     => $date->epochToHuman($asset->creationDate, '%y-%m-%d %j:%n:%s'),
                    lastUpdated     => $date->epochToHuman($asset->revisionDate, '%y-%m-%d %j:%n:%s'),
                    thumbnailUrl    => $siteUrl.$asset->getThumbnailUrl,
                    canAddFiles     => $asset->canAddFile,
                };
            }
        }
        $count++;
    }

    my $document = {
        pageNumber  => $pageNumber,
        gallery     => {
            canAddAlbums    => $self->canAddFile,
            title           => $self->getTitle,
            menuTitle       => $self->menuTitle,
            synopsis        => $self->synopsis,
            url             => $siteUrl.$self->getUrl,
            dateCreated     => $date->epochToHuman($self->creationDate, '%y-%m-%d %j:%n:%s'),
            lastUpdated     => $date->epochToHuman($self->revisionDate, '%y-%m-%d %j:%n:%s'),
        },
        albums      => \@assets
    };
    if ($as eq "xml") {
        $session->http->setMimeType('text/xml');
        return XML::Simple::XMLout($document, NoAttr => 1);
    }
    $session->http->setMimeType('application/json');
    return JSON->new->pretty->encode($document);
}

#----------------------------------------------------------------------------

=head2 www_search ( )

Search through the GalleryAlbums and files in this gallery. Show the form to
search and display the results if necessary.

=cut

sub www_search {
    my $self        = shift;
    my $session     = $self->session;
    my $form        = $session->form;
    my $db          = $session->db;

    my $var         = $self->getTemplateVars;
    # NOTE: Search form is added as part of getTemplateVars()

    # Get search results, if necessary.
    my $doSearch    
        = ( 
            $form->get( 'basicSearch' ) || $form->get( 'keywords' )
            || $form->get( 'title' ) || $form->get( 'description' )
            || $form->get( 'userId' ) || $form->get( 'className' )
            || $form->get( 'creationDate_after' ) || $form->get( 'creationDate_before' )
        );

    if ( $doSearch ) {
        # Keywords to search on
        # Do not add a space to the
        my $keywords;
        FORMVAR: foreach my $formVar (qw/ basicSearch keywords title description /) {
            my $var = $form->get($formVar);
            next FORMVAR unless $var;
            $keywords = join ' ', $keywords, $var;
        }

        # Build a where clause from the advanced options
        # Lineage search can capture gallery
        my $where       = q{assetIndex.assetId <> '} . $self->getId . q{'};
        if ( $form->get("title") ) {
            $where      .= q{ AND assetData.title LIKE } 
                        . $db->quote( '%' . $form->get("title") . '%' ) 
                        ;
        }
        if ( $form->get("description") ) {
            $where      .= q{ AND assetData.synopsis LIKE } 
                        . $db->quote( '%' . $form->get("description") . '%' ) 
                        ;
        }
        if ( $form->get("userId") ) {
            $where      .= q{ AND assetData.ownerUserId = }
                        . $db->quote( $form->get("userId") )
                        ;
        }

        my $oneYearAgo = WebGUI::DateTime->new( $session, time )->add( years => -1 )->epoch;
        my $dateAfter  = $form->get("creationDate_after", "dateTime", $oneYearAgo);
        my $dateBefore = $form->get("creationDate_before", "dateTime", time());
        my $creationDate = {};
        if ($dateAfter) {
            $creationDate->{start} = $dateAfter;
        }
        if ($dateBefore) {
            $creationDate->{end  } = $dateBefore;
        }

        # Classes
        my $joinClass   = [
            'WebGUI::Asset::Wobject::GalleryAlbum',
            'WebGUI::Asset::File::GalleryFile::Photo',
        ];
        if ( $form->get("className") ) {
            $joinClass  = [ $form->get('className') ];
        }
        $where      .= q{ AND assetIndex.className IN ( } . $db->quoteAndJoin( $joinClass ) . q{ ) };


        # Build a URL for the pagination
        my $url     
            = $self->getUrl( 
                'func=search;'
                . 'basicSearch=' . $form->get('basicSearch') . ';'
                . 'keywords=' . $form->get('keywords') . ';'
                . 'title=' . $form->get('title') . ';'
                . 'description=' . $form->get('description') . ';'
                . 'creationDate_after=' . $dateAfter . ';'
                . 'creationDate_before=' . $dateBefore . ';'
                . 'userId=' . $form->get("userId") . ';'
            );
        for my $class ( @$joinClass ) {
            $url    .= 'className=' . $class . ';';
        }

        my $p
            = $self->getSearchPaginator( { 
                url             => $url,
                keywords        => $keywords,
                where           => $where,
                joinClass       => $joinClass,
                creationDate    => $creationDate,
            } );

        $var->{ keywords }  = $keywords;

        $p->appendTemplateVars( $var );
        for my $result ( @{ $p->getPageData } ) {
            my $asset   = WebGUI::Asset->newById( $session, $result->{assetId} );
            push @{ $var->{search_results} }, {
                %{ $asset->getTemplateVars },
                isAlbum     => $asset->isa( 'WebGUI::Asset::Wobject::GalleryAlbum' ),
            };
        }
    }

    return $self->processStyle(
        $self->processTemplate( $var, $self->templateIdSearch )
    );
}

#----------------------------------------------------------------------------

=head2 www_listFilesForUser ( )

Show all the GalleryAlbums and files owned by a given userId. If no userId is
given, will use the current user.

=cut

sub www_listFilesForUser {
    my $self        = shift;
    my $session     = $self->session;
    my $var         = $self->getTemplateVars;
    my $userId      = $self->session->form->get("userId") || $self->session->user->userId;
    my $user        = WebGUI::User->new( $session, $userId );

    $var->{ url_rss         } = $self->getUrl('func=listFilesForUserRss;userId=' . $userId);
    $var->{ userId          } = $userId;
    $var->{ username        } = $user->username;

    # Get all the albums
    my $albumIds    = $self->getUserAlbumIds( $userId );
    for my $albumId ( @$albumIds ) {
        my $asset       = WebGUI::Asset->newById( $session, $albumId );
        push @{ $var->{user_albums} }, $asset->getTemplateVars;
    }

    # Get a page of files
    my $p
        = $self->getUserFilePaginator({ 
            userId          => $userId, 
            url             => $self->getUrl("func=listFilesForUser") 
        });
    $p->appendTemplateVars( $var );

    for my $fileId ( @{ $p->getPageData } ) {
        my $asset       = WebGUI::Asset->newById( $session, $fileId );
        push @{ $var->{user_files} }, $asset->getTemplateVars;
    }

    return $self->processStyle(
        $self->processTemplate( $var, $self->templateIdListFilesForUser )
    );
}

#----------------------------------------------------------------------------

=head2 www_listFilesForUserRss ( )

=cut

sub www_listFilesForUserRss {
    my $self        = shift;
    my $session     = $self->session;
    my $var         = $self->getTemplateVars;
    my $userId      = $self->session->form("userId") || $self->session->user->userId;

    # Fix URLs for template vars
    for my $key ( qw( url ) ) {
        $var->{ $key } = $self->session->url->getSiteURL . $var->{ $key };
    }

    # Get all the albums
    my $albumIds    = $self->getUserAlbumIds( $userId );
    for my $albumId ( @$albumIds ) {
        my $asset       = WebGUI::Asset->newById( $session, $albumId );
        my $assetVar    = $asset->getTemplateVars;

        for my $key ( qw( url ) ) {
            $assetVar->{ $key } = $self->session->url->getSiteURL . $assetVar->{ $key };
        }

        push @{ $var->{user_albums} }, $assetVar;
    }

    # Get all the files
    my $fileIds     = $self->getUserFileIds( $userId );
    for my $fileId ( @$fileIds ) {
        my $asset       = WebGUI::Asset->newById( $session, $fileId );
        my $assetVar    = $asset->getTemplateVars;

        for my $key ( qw( url ) ) {
            $assetVar->{ $key } = $self->session->url->getSiteURL . $assetVar->{ $key };
        }

        push @{ $var->{user_files} }, $assetVar;
    }

    $self->session->http->setMimeType('text/xml');
    return $self->processTemplate( $var, $self->templateIdListFilesForUserRss );
}

1;
