99a9da626d
Autocommit assets like CS posts or Calendar Events can now be added before the parent is committed. They will go into the same version tag as their parent.
1080 lines
30 KiB
Perl
1080 lines
30 KiB
Perl
package WebGUI::Asset::File::GalleryFile;
|
|
|
|
=head1 LEGAL
|
|
|
|
-------------------------------------------------------------------
|
|
WebGUI is Copyright 2001-2008 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
|
|
-------------------------------------------------------------------
|
|
|
|
=cut
|
|
|
|
use strict;
|
|
use base 'WebGUI::Asset::File';
|
|
|
|
use Carp qw( croak confess );
|
|
use URI::Escape;
|
|
use WebGUI::HTML;
|
|
use List::MoreUtils qw{ first_index };
|
|
|
|
|
|
=head1 NAME
|
|
|
|
WebGUI::Asset::File::GalleryFile - Superclass to create files for the Gallery
|
|
|
|
=head1 SYNOPSIS
|
|
|
|
|
|
=head1 DESCRIPTION
|
|
|
|
=head1 METHODS
|
|
|
|
These methods are available from this class
|
|
|
|
=cut
|
|
|
|
#-------------------------------------------------------------------
|
|
|
|
=head2 definition ( session, definition )
|
|
|
|
Define the properties of all GalleryFile assets.
|
|
|
|
=cut
|
|
|
|
sub definition {
|
|
my $class = shift;
|
|
my $session = shift;
|
|
my $definition = shift;
|
|
my $i18n = __PACKAGE__->i18n($session);
|
|
|
|
tie my %properties, 'Tie::IxHash', (
|
|
views => {
|
|
defaultValue => 0,
|
|
},
|
|
friendsOnly => {
|
|
defaultValue => 0,
|
|
},
|
|
rating => {
|
|
defaultValue => 0,
|
|
},
|
|
);
|
|
|
|
# UserDefined Fields
|
|
for my $i (1 .. 5) {
|
|
$properties{"userDefined".$i} = {
|
|
defaultValue => undef,
|
|
};
|
|
}
|
|
|
|
push @{$definition}, {
|
|
assetName => $i18n->get('assetName'),
|
|
autoGenerateForms => 0,
|
|
tableName => 'GalleryFile',
|
|
className => 'WebGUI::Asset::File::GalleryFile',
|
|
properties => \%properties,
|
|
};
|
|
|
|
return $class->SUPER::definition($session, $definition);
|
|
}
|
|
|
|
#----------------------------------------------------------------------------
|
|
|
|
=head2 appendTemplateVarsCommentForm ( var [, comment ] )
|
|
|
|
Add the template variables necessary for the comment form to the given hash
|
|
reference. Returns the hash reference for convenience. C<comment> is a hash
|
|
reference of values to populate the form with.
|
|
|
|
=cut
|
|
|
|
sub appendTemplateVarsCommentForm {
|
|
my $self = shift;
|
|
my $var = shift;
|
|
my $comment = shift || {};
|
|
my $session = $self->session;
|
|
|
|
# Default comment
|
|
$comment->{ commentId } ||= "new";
|
|
|
|
$var->{ commentForm_start }
|
|
= WebGUI::Form::formHeader( $session )
|
|
. WebGUI::Form::hidden( $session, {
|
|
name => "func",
|
|
value => "editCommentSave"
|
|
} )
|
|
. WebGUI::Form::hidden( $session, {
|
|
name => "commentId",
|
|
value => $comment->{ commentId }
|
|
} )
|
|
;
|
|
|
|
# Add hidden fields for editing a comment
|
|
if ( $comment->{ commentId } ne "new" ) {
|
|
$var->{ commentForm_start }
|
|
.= WebGUI::Form::hidden( $session, {
|
|
name => "userId",
|
|
value => $comment->{ userId }
|
|
} )
|
|
. WebGUI::Form::hidden( $session, {
|
|
name => "visitorIp",
|
|
value => $comment->{ visitorIp }
|
|
} )
|
|
. WebGUI::Form::hidden( $session, {
|
|
name => "creationDate",
|
|
value => $comment->{ creationDate }
|
|
} )
|
|
;
|
|
}
|
|
|
|
$var->{ commentForm_end }
|
|
= WebGUI::Form::formFooter( $session );
|
|
|
|
$var->{ commentForm_bodyText }
|
|
= WebGUI::Form::HTMLArea( $session, {
|
|
name => "bodyText",
|
|
richEditId => $self->getGallery->get("richEditIdComment"),
|
|
value => $comment->{ bodyText },
|
|
});
|
|
|
|
$var->{ commentForm_submit }
|
|
= WebGUI::Form::submit( $session, {
|
|
name => "submit",
|
|
value => "Save Comment",
|
|
});
|
|
|
|
return $var;
|
|
}
|
|
|
|
#----------------------------------------------------------------------------
|
|
|
|
=head2 canAdd ( )
|
|
|
|
Override canAdd to ignore its permissions check. Permissions are handled
|
|
by the parent Gallery and other permissions methods.
|
|
|
|
=cut
|
|
|
|
sub canAdd {
|
|
return 1;
|
|
}
|
|
|
|
#----------------------------------------------------------------------------
|
|
|
|
=head2 canComment ( [userId] )
|
|
|
|
Returns true if the user can comment on this asset. C<userId> is a WebGUI
|
|
user ID. If no userId is passed, check the current user.
|
|
|
|
Users can comment on this GalleryFile if they are allowed to view and the album
|
|
allows comments.
|
|
|
|
=cut
|
|
|
|
sub canComment {
|
|
my $self = shift;
|
|
my $userId = shift || $self->session->user->userId;
|
|
my $album = $self->getParent;
|
|
|
|
return 0 if !$self->canView($userId);
|
|
|
|
return $album->canComment($userId);
|
|
}
|
|
|
|
#----------------------------------------------------------------------------
|
|
|
|
=head2 canEdit ( [userId] )
|
|
|
|
Returns true if the user can edit this asset. C<userId> is a WebGUI user ID.
|
|
If no userId is passed, check the current user.
|
|
|
|
Users can edit this GalleryFile if they are the owner or if they are able to edit
|
|
the parent Album asset.
|
|
|
|
=cut
|
|
|
|
sub canEdit {
|
|
my $self = shift;
|
|
my $userId = shift || $self->session->user->userId;
|
|
my $album = $self->getParent;
|
|
|
|
return 1 if $userId eq $self->get("ownerUserId");
|
|
return $album->canEdit($userId);
|
|
}
|
|
|
|
#----------------------------------------------------------------------------
|
|
|
|
=head2 canEditIfLocked ( [userId] )
|
|
|
|
Override this to allow editing when locked under a different version tag.
|
|
|
|
=cut
|
|
|
|
sub canEditIfLocked {
|
|
my $self = shift;
|
|
my $userId = shift;
|
|
|
|
return $self->canEdit( $userId );
|
|
}
|
|
|
|
#----------------------------------------------------------------------------
|
|
|
|
=head2 canView ( [userId] )
|
|
|
|
Returns true if the user can view this asset. C<userId> is a WebGUI user ID.
|
|
If no user is passed, checks the current user.
|
|
|
|
Users can view this GalleryFile if they can view the parent asset. If this is a
|
|
C<friendsOnly> GalleryFile, then they must also be in the owners friends list.
|
|
|
|
=cut
|
|
|
|
sub canView {
|
|
my $self = shift;
|
|
my $userId = shift || $self->session->user->userId;
|
|
|
|
my $album = $self->getParent;
|
|
return 0 unless $album->canView($userId);
|
|
|
|
if ($self->isFriendsOnly && $userId != $self->get("ownerUserId") ) {
|
|
my $owner = WebGUI::User->new( $self->session, $self->get("ownerUserId") );
|
|
return 0
|
|
unless WebGUI::Friends->new($self->session, $owner)->isFriend($userId);
|
|
}
|
|
|
|
# Passed all checks
|
|
return 1;
|
|
}
|
|
|
|
#----------------------------------------------------------------------------
|
|
|
|
=head2 deleteComment ( commentId )
|
|
|
|
Delete a comment from this asset. C<id> is the ID of the comment to delete.
|
|
|
|
=cut
|
|
|
|
sub deleteComment {
|
|
my $self = shift;
|
|
my $commentId = shift;
|
|
|
|
croak "GalleryFile->deleteComment: No commentId specified."
|
|
unless $commentId;
|
|
|
|
return $self->session->db->write(
|
|
"DELETE FROM GalleryFile_comment WHERE assetId=? AND commentId=?",
|
|
[$self->getId, $commentId],
|
|
);
|
|
}
|
|
|
|
#----------------------------------------------------------------------------
|
|
|
|
=head2 getAutoCommitWorkflowId ( )
|
|
|
|
Returns the workflowId of the Gallery's approval workflow.
|
|
|
|
=cut
|
|
|
|
sub getAutoCommitWorkflowId {
|
|
my $self = shift;
|
|
my $gallery = $self->getGallery;
|
|
if ($gallery->hasBeenCommitted) {
|
|
return $gallery->get("workflowIdCommit")
|
|
|| $self->session->setting->get('defaultVersionTagWorkflow');
|
|
}
|
|
return undef;
|
|
}
|
|
|
|
#----------------------------------------------------------------------------
|
|
|
|
=head2 getComment ( commentId )
|
|
|
|
Get a comment from this asset. C<id> is the ID of the comment to get. Returns
|
|
a hash reference of comment information.
|
|
|
|
=cut
|
|
|
|
sub getComment {
|
|
my $self = shift;
|
|
my $commentId = shift;
|
|
|
|
return $self->session->db->getRow(
|
|
"GalleryFile_comment", "commentId", $commentId,
|
|
);
|
|
}
|
|
|
|
#----------------------------------------------------------------------------
|
|
|
|
=head2 getCommentIds ( )
|
|
|
|
Get an array reference of comment IDs for this GalleryFile, in chronological order.
|
|
|
|
=cut
|
|
|
|
sub getCommentIds {
|
|
my $self = shift;
|
|
|
|
return [
|
|
$self->session->db->buildArray(
|
|
"SELECT commentId FROM GalleryFile_comment WHERE assetId=?",
|
|
[$self->getId],
|
|
)
|
|
];
|
|
}
|
|
|
|
#----------------------------------------------------------------------------
|
|
|
|
=head2 getCommentPaginator ( )
|
|
|
|
Get a WebGUI::Paginator for the comments for this GalleryFile.
|
|
|
|
=cut
|
|
|
|
sub getCommentPaginator {
|
|
my $self = shift;
|
|
my $session = $self->session;
|
|
|
|
my $p = WebGUI::Paginator->new($session, $self->getUrl);
|
|
$p->setDataByQuery(
|
|
"SELECT * FROM GalleryFile_comment WHERE assetId=? ORDER BY creationDate DESC",
|
|
undef, undef,
|
|
[$self->getId],
|
|
);
|
|
|
|
return $p;
|
|
}
|
|
|
|
#----------------------------------------------------------------------------
|
|
|
|
=head2 getCurrentRevisionDate ( session, assetId )
|
|
|
|
Override this to allow instanciation of "pending" GalleryFiles for those who
|
|
are authorized to see them.
|
|
|
|
=cut
|
|
|
|
sub getCurrentRevisionDate {
|
|
my $class = shift;
|
|
my $session = shift;
|
|
my $assetId = shift;
|
|
|
|
# Get the highest revision date, instanciate the asset, and see if
|
|
# the permissions are enough to return the revisionDate.
|
|
my $revisionDate
|
|
= $session->db->quickScalar(
|
|
"SELECT MAX(revisionDate) FROM GalleryFile WHERE assetId=?",
|
|
[ $assetId ]
|
|
);
|
|
|
|
return undef unless $revisionDate;
|
|
|
|
my $asset = WebGUI::Asset->new( $session, $assetId, $class, $revisionDate );
|
|
|
|
return undef unless $asset;
|
|
|
|
if ( $asset->get( 'status' ) eq "approved" || $asset->canEdit ) {
|
|
return $revisionDate;
|
|
}
|
|
else {
|
|
return $class->SUPER::getCurrentRevisionDate( $session, $assetId );
|
|
}
|
|
}
|
|
|
|
#----------------------------------------------------------------------------
|
|
|
|
=head2 getGallery ( )
|
|
|
|
Gets the Gallery asset this GalleryFile is a member of.
|
|
|
|
=cut
|
|
|
|
sub getGallery {
|
|
my $self = shift;
|
|
|
|
# We must use getParent->getParent because brand-new assets do not
|
|
# have a lineage, but they do get assigned a parent.
|
|
return $self->getParent->getParent;
|
|
}
|
|
|
|
#----------------------------------------------------------------------------
|
|
|
|
=head2 getParent ( )
|
|
|
|
Get the parent GalleryAlbum. If the only revision of the GalleryAlbum is
|
|
"pending", return that anyway.
|
|
|
|
=cut
|
|
|
|
sub getParent {
|
|
my $self = shift;
|
|
if ( my $album = $self->SUPER::getParent ) {
|
|
return $album;
|
|
}
|
|
# Only get the pending version if we're allowed to see this photo in its pending status
|
|
elsif ( $self->getGallery->canEdit || $self->get( 'ownerUserId' ) eq $self->session->user->userId ) {
|
|
my $album
|
|
= $self->getLineage( ['ancestors'], {
|
|
includeOnlyClasses => [ 'WebGUI::Asset::Wobject::GalleryAlbum' ],
|
|
returnObjects => 1,
|
|
statusToInclude => [ 'pending', 'approved' ],
|
|
invertTree => 1,
|
|
} )->[ 0 ];
|
|
return $album;
|
|
}
|
|
}
|
|
|
|
#----------------------------------------------------------------------------
|
|
|
|
=head2 getThumbnailUrl ( )
|
|
|
|
Gets the URL to the thumbnail for this GalleryFile. This should probably be
|
|
overridded by your child class.
|
|
|
|
=cut
|
|
|
|
sub getThumbnailUrl {
|
|
my $self = shift;
|
|
|
|
# TODO: Make a "default" thumbnail
|
|
}
|
|
|
|
#----------------------------------------------------------------------------
|
|
|
|
=head2 getTemplateVars ( )
|
|
|
|
Gets the template vars for this GalleryFile. You should probably extend this
|
|
method.
|
|
|
|
=cut
|
|
|
|
sub getTemplateVars {
|
|
my $self = shift;
|
|
my $session = $self->session;
|
|
my $var = $self->get;
|
|
my $owner = WebGUI::User->new( $session, $self->get("ownerUserId") );
|
|
|
|
$var->{ fileUrl } = $self->getFileUrl;
|
|
$var->{ thumbnailUrl } = $self->getThumbnailUrl;
|
|
|
|
# Set a flag for pending files
|
|
if ( $self->get( "status" ) eq "pending" ) {
|
|
$var->{ 'isPending' } = 1;
|
|
}
|
|
|
|
# Fix 'undef' vars since HTML::Template does inheritence on them
|
|
for my $key ( qw( synopsis ) ) {
|
|
unless ( defined $var->{$key} ) {
|
|
$var->{ $key } = '';
|
|
}
|
|
}
|
|
|
|
# Add some things from Gallery
|
|
my $galleryVar = $self->getGallery->getTemplateVars;
|
|
for my $key ( qw{ url_listFilesForCurrentUser url_search } ) {
|
|
$var->{ $key } = $galleryVar->{ $key };
|
|
}
|
|
|
|
# More things from Gallery, but with different names
|
|
for my $key ( qw{ title menuTitle url } ) {
|
|
$var->{ "gallery_" . $key } = $galleryVar->{ $key };
|
|
}
|
|
|
|
# Add some things from Album
|
|
my $album = $self->getParent;
|
|
my $albumVar = $album->getTemplateVars;
|
|
for my $key ( qw{ title menuTitle url thumbnailUrl } ) {
|
|
$var->{ "album_" . $key } = $albumVar->{ $key };
|
|
}
|
|
|
|
# Add the search form
|
|
$self->getGallery->appendTemplateVarsSearchForm( $var );
|
|
|
|
# Add a text-only synopsis
|
|
$var->{ synopsis_textonly } = WebGUI::HTML::filter( $self->get('synopsis'), "all" );
|
|
|
|
# Figure out on what page of the album the gallery file belongs.
|
|
my $fileIdsInAlbum = $album->getFileIds;
|
|
my $pageNumber =
|
|
int (
|
|
( first_index { $_ eq $self->getId } @{ $fileIdsInAlbum } ) # Get index of file in album
|
|
/ $album->getParent->get( 'defaultFilesPerPage' ) # Divide by the number of files per page
|
|
) + 1; # Round upwards
|
|
|
|
$var->{ canComment } = $self->canComment;
|
|
$var->{ canEdit } = $self->canEdit;
|
|
$var->{ numberOfComments } = scalar @{ $self->getCommentIds };
|
|
$var->{ ownerUsername } = $owner->profileField("alias") || $owner->username;
|
|
$var->{ url } = $self->getUrl;
|
|
$var->{ url_addArchive } = $self->getParent->getUrl('func=addArchive'),
|
|
$var->{ url_delete } = $self->getUrl('func=delete');
|
|
$var->{ url_demote } = $self->getUrl('func=demote');
|
|
$var->{ url_edit } = $self->getUrl('func=edit');
|
|
$var->{ url_gallery } = $self->getGallery->getUrl;
|
|
$var->{ url_album } = $self->getParent->getUrl("pn=$pageNumber");
|
|
$var->{ url_thumbnails } = $self->getParent->getUrl('func=thumbnails');
|
|
$var->{ url_slideshow } = $self->getParent->getUrl('func=slideshow');
|
|
$var->{ url_makeShortcut } = $self->getUrl('func=makeShortcut');
|
|
$var->{ url_listFilesForOwner }
|
|
= $self->getGallery->getUrl('func=listFilesForUser;userId=' . $self->get("ownerUserId"));
|
|
$var->{ url_promote } = $self->getUrl('func=promote');
|
|
|
|
return $var;
|
|
}
|
|
|
|
|
|
#----------------------------------------------------------------------------
|
|
|
|
=head2 i18n ( session )
|
|
|
|
Get the i18n object for this class. This sub must not be inherited, so always
|
|
call it using C<__PACKAGE__>, not C<$self>.
|
|
|
|
=cut
|
|
|
|
sub i18n {
|
|
my $self = shift;
|
|
my $session = shift;
|
|
# TODO: Make a migration script to move the appropriate parts from
|
|
# Asset_Photo to Asset_GalleryFile
|
|
return WebGUI::International->new( $session, "Asset_Photo" );
|
|
}
|
|
|
|
#----------------------------------------------------------------------------
|
|
|
|
=head2 isFriendsOnly ( )
|
|
|
|
Returns true if this GalleryFile is friends only. Returns false otherwise.
|
|
|
|
=cut
|
|
|
|
sub isFriendsOnly {
|
|
my $self = shift;
|
|
return $self->get("friendsOnly");
|
|
}
|
|
|
|
#----------------------------------------------------------------------------
|
|
|
|
=head2 makeShortcut ( parentId [, overrides ] )
|
|
|
|
Make a shortcut to this asset under the specified parent, optionally adding
|
|
the specified hash reference of C<overrides>.
|
|
|
|
Returns the created shortcut asset.
|
|
|
|
=cut
|
|
|
|
sub makeShortcut {
|
|
my $self = shift;
|
|
my $parentId = shift;
|
|
my $overrides = shift;
|
|
my $session = $self->session;
|
|
|
|
croak "GalleryFile->makeShortcut: parentId must be defined"
|
|
unless $parentId;
|
|
|
|
my $parent = WebGUI::Asset->newByDynamicClass($session, $parentId)
|
|
|| croak "GalleryFile->makeShortcut: Could not instanciate asset '$parentId'";
|
|
|
|
my $shortcut
|
|
= $parent->addChild({
|
|
className => "WebGUI::Asset::Shortcut",
|
|
shortcutToAssetId => $self->getId,
|
|
});
|
|
|
|
if ($overrides) {
|
|
$shortcut->setOverride( $overrides );
|
|
}
|
|
|
|
return $shortcut;
|
|
}
|
|
|
|
#----------------------------------------------------------------------------
|
|
|
|
=head2 prepareView ( )
|
|
|
|
Prepare the template to be used for the C<view> method.
|
|
|
|
=cut
|
|
|
|
sub prepareView {
|
|
my $self = shift;
|
|
$self->SUPER::prepareView();
|
|
|
|
my $template
|
|
= WebGUI::Asset::Template->new($self->session, $self->getGallery->get("templateIdViewFile"));
|
|
$template->prepare($self->getMetaDataAsTemplateVariables);
|
|
|
|
$self->{_viewTemplate} = $template;
|
|
}
|
|
|
|
#----------------------------------------------------------------------------
|
|
|
|
=head2 processCommentEditForm ( )
|
|
|
|
Process the Comment Add / Edit Form. Returns a hash reference of properties
|
|
that can be passed to C<setComment>.
|
|
|
|
Will die with an i18n-friendly error message if something is missing or
|
|
wrong.
|
|
|
|
=cut
|
|
|
|
sub processCommentEditForm {
|
|
my $self = shift;
|
|
my $session = $self->session;
|
|
my $form = $self->session->form;
|
|
my $now = WebGUI::DateTime->new( $session, time );
|
|
my $i18n = __PACKAGE__->i18n( $session );
|
|
|
|
# Using die here to suppress line number and file path info
|
|
die $i18n->get("commentForm error no commentId") . "\n"
|
|
unless $form->get("commentId");
|
|
die $i18n->get("commentForm error no bodyText") . "\n"
|
|
unless $form->get("bodyText");
|
|
|
|
my $new = $form->get('commentId') eq "new"
|
|
? 1
|
|
: 0
|
|
;
|
|
|
|
my $visitorIp = $session->user->isVisitor
|
|
? $session->env->get("REMOTE_ADDR")
|
|
: undef
|
|
;
|
|
|
|
my $properties = {
|
|
commentId => $form->get("commentId"),
|
|
assetId => $self->getId,
|
|
bodyText => $form->get("bodyText"),
|
|
creationDate => ( $new ? $now->toDatabaseDate : $form->get("creationDate") ),
|
|
userId => ( $new ? $session->user->userId : $form->get("userId") ),
|
|
visitorIp => ( $new ? $visitorIp : $form->get("visitorIp") ),
|
|
};
|
|
|
|
return $properties;
|
|
}
|
|
|
|
#----------------------------------------------------------------------------
|
|
|
|
=head2 processPropertiesFromFormPost ( )
|
|
|
|
|
|
=cut
|
|
|
|
sub processPropertiesFromFormPost {
|
|
my $self = shift;
|
|
my $i18n = __PACKAGE__->i18n( $self->session );
|
|
my $form = $self->session->form;
|
|
my $errors = $self->SUPER::processPropertiesFromFormPost || [];
|
|
|
|
# Make sure we have the disk space for this
|
|
if ( !$self->getGallery->hasSpaceAvailable( $self->get( 'assetSize' ) ) ) {
|
|
push @{ $errors }, $i18n->get( "error no space" );
|
|
}
|
|
|
|
# Return if errors
|
|
return $errors if @$errors;
|
|
|
|
### Passes all checks
|
|
|
|
# If the album doesn't yet have a thumbnail, make this File the thumbnail
|
|
if ( !$self->getParent->get('assetIdThumbnail') ) {
|
|
$self->getParent->update( {
|
|
assetIdThumbnail => $self->getId,
|
|
} );
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
#----------------------------------------------------------------------------
|
|
|
|
=head2 processStyle ( html )
|
|
|
|
Returns the HTML from the Gallery's style.
|
|
|
|
=cut
|
|
|
|
sub processStyle {
|
|
my $self = shift;
|
|
return $self->getGallery->processStyle( @_ );
|
|
}
|
|
|
|
#----------------------------------------------------------------------------
|
|
|
|
=head2 purge ( )
|
|
|
|
Purge the asset. Remove all comments on the GalleryFile.
|
|
|
|
=cut
|
|
|
|
sub purge {
|
|
my $self = shift;
|
|
|
|
for my $commentId ( @{ $self->getCommentIds } ) {
|
|
$self->deleteComment( $commentId );
|
|
}
|
|
|
|
return $self->SUPER::purge;
|
|
}
|
|
|
|
#----------------------------------------------------------------------------
|
|
|
|
=head2 setComment ( properties )
|
|
|
|
Set a comment. C<properties> is a hash reference of comment information with
|
|
the following keys:
|
|
|
|
assetId - The assetId of the asset this comment is for
|
|
commentId - The ID of the comment. If "new", will make a new comment.
|
|
bodyText - The body of the comment
|
|
userId - The userId of the user who made the comment
|
|
visitorIp - If the user was a visitor, the IP address of the user
|
|
creationDate - A MySQL-formatted date/time when the comment was posted
|
|
|
|
=cut
|
|
|
|
sub setComment {
|
|
my $self = shift;
|
|
my $properties = shift;
|
|
|
|
croak "GalleryFile->setComment: properties must be a hash reference"
|
|
unless $properties && ref $properties eq "HASH";
|
|
croak "GalleryFile->setComment: commentId must be defined"
|
|
unless $properties->{ commentId };
|
|
croak "GalleryFile->setComment: properties must contain a bodyText key"
|
|
unless $properties->{ bodyText };
|
|
|
|
$properties->{ creationDate } ||= WebGUI::DateTime->new($self->session, time)->toDatabase;
|
|
$properties->{ assetId } = $self->getId;
|
|
|
|
return $self->session->db->setRow(
|
|
"GalleryFile_comment", "commentId",
|
|
$properties,
|
|
);
|
|
}
|
|
|
|
#----------------------------------------------------------------------------
|
|
|
|
=head2 view ( )
|
|
|
|
method called by the container www_view method.
|
|
|
|
=cut
|
|
|
|
sub view {
|
|
my $self = shift;
|
|
my $session = $self->session;
|
|
my $var = $self->getTemplateVars;
|
|
|
|
$self->appendTemplateVarsCommentForm( $var );
|
|
|
|
# Keywords
|
|
my $k = WebGUI::Keyword->new( $session );
|
|
my $keywords = $k->getKeywordsForAsset( { asArrayRef => 1, asset => $self } );
|
|
for my $keyword ( @{ $keywords } ) {
|
|
push @{ $var->{keywords} }, {
|
|
keyword => $keyword,
|
|
url_searchKeyword
|
|
=> $self->getGallery->getUrl(
|
|
"func=search;submit=1;keywords=" . uri_escape($keyword)
|
|
),
|
|
url_searchKeywordUser
|
|
=> $self->getGallery->getUrl(
|
|
"func=search;submit=1;"
|
|
. "userId=" . $self->get("ownerUserId") . ';'
|
|
. 'keywords=' . uri_escape( $keyword )
|
|
),
|
|
};
|
|
}
|
|
|
|
# Comments
|
|
my $p = $self->getCommentPaginator;
|
|
for my $comment ( @{ $p->getPageData } ) {
|
|
$comment->{ url_deleteComment }
|
|
= $self->getUrl('func=deleteComment;commentId=' . $comment->{commentId} );
|
|
$comment->{ url_editComment }
|
|
= $self->getUrl('func=editComment;commentId=' . $comment->{commentId} );
|
|
|
|
my $user = WebGUI::User->new( $session, $comment->{userId} );
|
|
$comment->{ username } = $user->username;
|
|
|
|
my $dt = WebGUI::DateTime->new( $session, $comment->{ creationDate } );
|
|
$comment->{ creationDate } = $dt->toUserTimeZone;
|
|
|
|
push @{ $var->{commentLoop} }, $comment;
|
|
}
|
|
$var->{ commentLoop_pageBar } = $p->getBarAdvanced;
|
|
|
|
return $self->processTemplate($var, undef, $self->{_viewTemplate});
|
|
}
|
|
|
|
#----------------------------------------------------------------------------
|
|
|
|
=head2 www_delete ( )
|
|
|
|
Show the page to confirm the deletion of this GalleryFile. Show a list of albums
|
|
this GalleryFile exists in.
|
|
|
|
=cut
|
|
|
|
sub www_delete {
|
|
my $self = shift;
|
|
my $session = $self->session;
|
|
|
|
return $self->session->privilege->insufficient unless $self->canEdit;
|
|
|
|
my $var = $self->getTemplateVars;
|
|
$var->{ url_yes } = $self->getUrl("func=deleteConfirm");
|
|
|
|
# TODO Get albums with shortcuts to this asset
|
|
|
|
return $self->processStyle(
|
|
$self->processTemplate( $var, $self->getGallery->get("templateIdDeleteFile") )
|
|
);
|
|
}
|
|
|
|
#----------------------------------------------------------------------------
|
|
|
|
=head2 www_deleteComment ( )
|
|
|
|
Delete a comment immediately. Only those who can edit this GalleryFile can delete
|
|
comments on it.
|
|
|
|
=cut
|
|
|
|
sub www_deleteComment {
|
|
my $self = shift;
|
|
my $session = $self->session;
|
|
|
|
return $session->privilege->insufficient unless $self->canEdit;
|
|
|
|
my $i18n = __PACKAGE__->i18n( $session );
|
|
my $commentId = $session->form->get('commentId');
|
|
|
|
$self->deleteComment( $commentId );
|
|
|
|
return $self->www_view;
|
|
}
|
|
|
|
#----------------------------------------------------------------------------
|
|
|
|
=head2 www_deleteConfirm ( )
|
|
|
|
Confirm the deletion of this GalleryFile. Show a message and a link back to the
|
|
album.
|
|
|
|
=cut
|
|
|
|
sub www_deleteConfirm {
|
|
my $self = shift;
|
|
|
|
return $self->session->privilege->insufficient unless $self->canEdit;
|
|
|
|
my $i18n = __PACKAGE__->i18n( $self->session );
|
|
|
|
$self->purge;
|
|
|
|
return $self->processStyle(
|
|
sprintf $i18n->get("delete message"), $self->getParent->getUrl,
|
|
);
|
|
}
|
|
|
|
#----------------------------------------------------------------------------
|
|
|
|
=head2 www_editComment ( params )
|
|
|
|
Form to edit a comment. C<params> is a hash reference of parameters
|
|
with the following keys:
|
|
|
|
errors = An array reference of errors to show the user.
|
|
|
|
=cut
|
|
|
|
sub www_editComment {
|
|
my $self = shift;
|
|
my $params = shift;
|
|
my $session = $self->session;
|
|
|
|
# Get the comment, if needed
|
|
my $commentId = $session->form->get( "commentId" );
|
|
my $comment = $commentId ne "new"
|
|
? $self->getComment( $commentId )
|
|
: {}
|
|
;
|
|
|
|
# Check permissions
|
|
# Adding a new comment
|
|
if ( $commentId eq "new" ) {
|
|
return $session->privilege->insufficient unless $self->canComment;
|
|
}
|
|
# Editing your own comment
|
|
elsif ( $comment->{ userId } ne "1" && $comment->{ userId } eq $self->session->user->userId ) {
|
|
return $session->privilege->insufficient unless $self->canComment;
|
|
}
|
|
# Editing someone else's comment
|
|
else {
|
|
return $session->privilege->insufficient unless $self->canEdit;
|
|
}
|
|
|
|
my $var = $self->getTemplateVars;
|
|
|
|
if ( $params->{ errors } ) {
|
|
$var->{ errors } = [ map { { "error" => $_ } } @{ $params->{errors} } ];
|
|
}
|
|
|
|
$self->appendTemplateVarsCommentForm( $var, $comment );
|
|
|
|
$var->{ isNew } = $commentId eq "new";
|
|
|
|
return $self->processStyle(
|
|
$self->processTemplate( $var, $self->getGallery->get("templateIdEditComment") )
|
|
);
|
|
}
|
|
|
|
#----------------------------------------------------------------------------
|
|
|
|
=head2 www_editCommentSave ( )
|
|
|
|
Save a comment being edited
|
|
|
|
=cut
|
|
|
|
sub www_editCommentSave {
|
|
my $self = shift;
|
|
my $session = $self->session;
|
|
my $i18n = __PACKAGE__->i18n( $session );
|
|
|
|
# Process the form first, so we can know how to check permissions
|
|
my $comment = eval { $self->processCommentEditForm };
|
|
if ( $@ ) {
|
|
return $self->www_editComment( { errors => [ $@ ] } );
|
|
}
|
|
|
|
# Check permissions
|
|
# Adding a new comment
|
|
if ( $comment->{ commentId } eq "new" ) {
|
|
return $session->privilege->insufficient unless $self->canComment;
|
|
}
|
|
# Editing your own comment
|
|
elsif ( $comment->{ userId } ne "1" && $comment->{ userId } eq $self->session->user->userId ) {
|
|
return $session->privilege->insufficient unless $self->canComment;
|
|
}
|
|
# Editing someone else's comment
|
|
else {
|
|
return $session->privilege->insufficient unless $self->canEdit;
|
|
}
|
|
|
|
# setComment changes commentId, so keep track if we're adding a new comment
|
|
my $isNew = $comment->{commentId} eq "new";
|
|
$self->setComment( $comment );
|
|
|
|
# Return different message for adding and editing
|
|
if ( $isNew ) {
|
|
return $self->processStyle(
|
|
sprintf $i18n->get('comment message'), $self->getUrl
|
|
);
|
|
}
|
|
else {
|
|
return $self->processStyle(
|
|
sprintf $i18n->get('editCommentSave message'), $self->getUrl
|
|
);
|
|
}
|
|
}
|
|
|
|
#----------------------------------------------------------------------------
|
|
|
|
=head2 www_makeShortcut ( )
|
|
|
|
Display the form to make a shortcut.
|
|
|
|
=cut
|
|
|
|
sub www_makeShortcut {
|
|
my $self = shift;
|
|
my $session = $self->session;
|
|
|
|
# Create the form to make a shortcut
|
|
my $var = $self->getTemplateVars;
|
|
|
|
$var->{ form_start }
|
|
= WebGUI::Form::formHeader( $session )
|
|
. WebGUI::Form::hidden( $session, { name => "func", value => "makeShortcutSave" });
|
|
$var->{ form_end }
|
|
= WebGUI::Form::formFooter( $session );
|
|
|
|
# Albums under this Gallery
|
|
my $albums = $self->getGallery->getAlbumIds;
|
|
my %albumOptions;
|
|
for my $assetId ( @$albums ) {
|
|
my $asset = WebGUI::Asset->newByDynamicClass($session, $assetId);
|
|
if ($asset->canAddFile) {
|
|
$albumOptions{ $assetId } = $asset->get("title");
|
|
}
|
|
}
|
|
$var->{ form_parentId }
|
|
= WebGUI::Form::selectBox( $session, {
|
|
name => "parentId",
|
|
value => $self->getParent->getId,
|
|
options => \%albumOptions,
|
|
});
|
|
|
|
return $self->processStyle(
|
|
$self->processTemplate($var, $self->getGallery->get("templateIdMakeShortcut"))
|
|
);
|
|
}
|
|
|
|
#----------------------------------------------------------------------------
|
|
|
|
=head2 www_makeShortcutSave ( )
|
|
|
|
Make the shortcut.
|
|
|
|
This page is only available to those who can edit this GalleryFile.
|
|
|
|
=cut
|
|
|
|
sub www_makeShortcutSave {
|
|
my $self = shift;
|
|
my $form = $self->session->form;
|
|
|
|
my $parentId = $form->get('parentId');
|
|
my $shortcut = $self->makeShortcut( $parentId );
|
|
|
|
return $shortcut->www_view;
|
|
}
|
|
|
|
#----------------------------------------------------------------------------
|
|
|
|
=head2 www_view ( )
|
|
|
|
Shows the output of L<view> inside of the style provided by the gallery this
|
|
GalleryFile is in.
|
|
|
|
=cut
|
|
|
|
sub www_view {
|
|
my $self = shift;
|
|
|
|
return $self->session->privilege->insufficient unless $self->canView;
|
|
|
|
# Add to views
|
|
$self->update({ views => $self->get('views') + 1 });
|
|
|
|
$self->session->http->setLastModified($self->getContentLastModified);
|
|
$self->session->http->sendHeader;
|
|
$self->prepareView;
|
|
my $style = $self->processStyle("~~~");
|
|
my ($head, $foot) = split("~~~",$style);
|
|
$self->session->output->print($head, 1);
|
|
$self->session->output->print($self->view);
|
|
$self->session->output->print($foot, 1);
|
|
return "chunked";
|
|
}
|
|
|
|
|
|
1; # Who knew the truth would be so obvious?
|