703 lines
20 KiB
Perl
703 lines
20 KiB
Perl
package WebGUI::Page;
|
|
|
|
=head1 LEGAL
|
|
|
|
-------------------------------------------------------------------
|
|
WebGUI is Copyright 2001-2004 Plain Black LLC.
|
|
-------------------------------------------------------------------
|
|
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 warnings;
|
|
use HTML::Template;
|
|
use strict;
|
|
use Tie::IxHash;
|
|
use WebGUI::ErrorHandler;
|
|
use WebGUI::HTMLForm;
|
|
use WebGUI::Icon;
|
|
use WebGUI::Persistent::Tree;
|
|
use WebGUI::Session;
|
|
use WebGUI::SQL;
|
|
use WebGUI::Template;
|
|
use WebGUI::Utility;
|
|
use WebGUI::DateTime;
|
|
use Data::Serializer;
|
|
|
|
our @ISA = qw(WebGUI::Persistent::Tree);
|
|
|
|
=head1 NAME
|
|
|
|
Package WebGUI::Page
|
|
|
|
=head1 DESCRIPTION
|
|
|
|
This package provides utility functions for WebGUI's page system. Some of these work in a
|
|
non-object oriented fashion. These are utility functions, not affecting the page tree hiearchy.
|
|
|
|
The methods that do affect this hiearchy should be called in a object oriented context.
|
|
|
|
=head1 SYNOPSIS
|
|
|
|
Non OO functions
|
|
|
|
use WebGUI::Page;
|
|
$integer = WebGUI::Page::countTemplatePositions($templateId);
|
|
$html = WebGUI::Page::drawTemplate($templateId);
|
|
$html = WebGUI::Page::generate();
|
|
$hashRef = WebGUI::Page::getTemplateList();
|
|
$template = WebGUI::Page::getTemplate();
|
|
$hashRef = WebGUI::Page::getTemplatePositions($templateId);
|
|
$url = WebGUI::Page::makeUnique($url,$pageId);
|
|
|
|
|
|
OO style methods
|
|
|
|
use WebGUI::Page;
|
|
$page = WebGUI::Page->getPage($pageId);
|
|
$newMother = WebGUI::Page->getPage($anotherPageId);
|
|
$page->cut;
|
|
$page->paste($newMother);
|
|
|
|
$page->set; # this automatically recaches the pagetree
|
|
|
|
$page->setWithoutRecache;
|
|
WebGUI::Page->recachePageTree # here we've got to recache manually
|
|
|
|
=head1 METHODS
|
|
|
|
These functions are available from this package:
|
|
|
|
=cut
|
|
|
|
#-------------------------------------------------------------------
|
|
|
|
sub classSettings {
|
|
return {
|
|
properties => {
|
|
# These fields define the place in the pagetree of a page
|
|
pageId => { key => 1 },
|
|
parentId => { defaultValue => 0 },
|
|
sequenceNumber => { defaultValue => 1 },
|
|
|
|
# These are the entries that define the privileges and behaviour of a page.
|
|
# They're in the same order as they apear in the set-statement in the www_editPageSave method
|
|
# of WebGUI::Operation::Page. Please keep them in this order. You will find it to be more
|
|
# convient when debugging.
|
|
title => { quote => 1 },
|
|
styleId => { defaultValue => 0 },
|
|
printableStyleId => { defaultValue => 0 },
|
|
ownerId => { defaultValue => 0 },
|
|
groupIdView => { defaultValue => 3 },
|
|
groupIdEdit => { defaultValue => 3 },
|
|
newWindow => { defaultValue => 0 },
|
|
wobjectPrivileges => { defaultValue => 0 },
|
|
hideFromNavigation => { defaultValue => 0 },
|
|
startDate => { defaultValue => 946710000 },
|
|
endDate => { defaultValue => 2082783600 },
|
|
cacheTimeout => { defaultValue => 60},
|
|
cacheTimeoutVisitor => { defaultValue => 600},
|
|
metaTags => { quote => 1 },
|
|
urlizedTitle => { quote => 1 },
|
|
redirectURL => { quote => 1 },
|
|
languageId => { defaultValue => 1 },
|
|
defaultMetaTags => { defaultValue => 0 },
|
|
templateId => { defaultValue => 1 },
|
|
menuTitle => { quote => 1 },
|
|
synopsis => { quote => 1 },
|
|
|
|
# The clipboard/trash properties.
|
|
bufferUserId => { },
|
|
bufferDate => { },
|
|
bufferPrevId => { },
|
|
|
|
# The userdefined database entries.
|
|
userDefined1 => { quote => 1 },
|
|
userDefined2 => { quote => 1 },
|
|
userDefined3 => { quote => 1 },
|
|
userDefined4 => { quote => 1 },
|
|
userDefined5 => { quote => 1 }
|
|
},
|
|
useDummyRoot => 1,
|
|
table => 'page'
|
|
}
|
|
}
|
|
|
|
#-------------------------------------------------------------------
|
|
=head2 add ( page )
|
|
|
|
Adds page to the children of the object this method is invoked on.
|
|
|
|
=over
|
|
|
|
=item page
|
|
|
|
A WebGUI::Page instance to be added to the children of the current object.
|
|
|
|
=back
|
|
|
|
=cut
|
|
|
|
sub add {
|
|
my ($self, $page, @daughters, $newSequenceNumber);
|
|
($self) = @_;
|
|
|
|
@daughters = $self->daughters;
|
|
$newSequenceNumber = 1;
|
|
$newSequenceNumber = (pop(@daughters))[0]->get('sequenceNumber') + 1 if (@daughters);
|
|
|
|
$page = WebGUI::Page->new(-properties => {
|
|
parentId => $self->get("pageId"),
|
|
sequenceNumber => $newSequenceNumber
|
|
});
|
|
$self->add_daughter($page);
|
|
$page->set;
|
|
|
|
return $page;
|
|
}
|
|
|
|
#-------------------------------------------------------------------
|
|
|
|
=head2 countTemplatePositions ( templateId )
|
|
|
|
Returns the number of template positions in the specified page template.
|
|
|
|
=over
|
|
|
|
=item templateId
|
|
|
|
The id of the page template you wish to count.
|
|
|
|
=back
|
|
|
|
=cut
|
|
|
|
sub countTemplatePositions {
|
|
my ($template, $i);
|
|
$template = getTemplate($_[0]);
|
|
$i = 1;
|
|
while ($template =~ m/position$i\_loop/) {
|
|
$i++;
|
|
}
|
|
return $i-1;
|
|
}
|
|
|
|
#-------------------------------------------------------------------
|
|
=head2 cut
|
|
|
|
Cuts the this Page object and places it on the clipboard.
|
|
|
|
=back
|
|
|
|
=cut
|
|
sub cut {
|
|
my ($self, $clipboard, $parentId);
|
|
$self = shift;
|
|
$parentId = $self->get("parentId");
|
|
|
|
# Place page in clipboard (pageId 2)
|
|
$clipboard = WebGUI::Page->getPage(2);
|
|
|
|
if ($self->move($clipboard)) {
|
|
$self->set({
|
|
bufferUserId => $session{user}{userId},
|
|
bufferDate => time,
|
|
bufferPrevId => $parentId,
|
|
});
|
|
}
|
|
|
|
return $self;
|
|
}
|
|
|
|
#-------------------------------------------------------------------
|
|
=head2 deCache ( [ pageId ] )
|
|
|
|
Deletes the cached version of a specified page. Note that this is something else than the
|
|
cached page tree. This funtion should be invoked in a non-OO context;
|
|
|
|
=over
|
|
|
|
=item pageId
|
|
|
|
The id of the page to decache. Defaults to the current page id.
|
|
|
|
=back
|
|
|
|
=cut
|
|
|
|
sub deCache {
|
|
my $cache = WebGUI::Cache->new;
|
|
my $pageId = $_[0] || $session{page}{pageId};
|
|
$cache->deleteByRegex("m/^page_".$pageId."_\\d+\$/");
|
|
}
|
|
|
|
#-------------------------------------------------------------------
|
|
=head2 delete
|
|
|
|
Deletes this Page object from the tree and places it in the trash. To physically remove
|
|
pages from the tree and the database you should use the purge method.
|
|
|
|
This function overloads the delete inherited from WebGUI::Persistent::Tree. This is done
|
|
because 'delete' is the right name for the functionality within WebGUI and because the
|
|
delete of WG::P::Tree is not very useful: it only works on one page and causes pages with
|
|
'zombie' parents.
|
|
|
|
=back
|
|
|
|
=cut
|
|
sub delete {
|
|
my ($self, $trash, $parentId);
|
|
$self = shift;
|
|
$parentId = $self->get("parentId");
|
|
|
|
# Place page in trash (pageId 3)
|
|
$trash = WebGUI::Page->getPage(3);
|
|
|
|
if ($self->move($trash)) {
|
|
$self->set({
|
|
bufferUserId => $session{user}{userId},
|
|
bufferDate => time,
|
|
bufferPrevId => $parentId,
|
|
});
|
|
}
|
|
|
|
return $self;
|
|
}
|
|
|
|
#-------------------------------------------------------------------
|
|
=head2 drawTemplate ( templateId )
|
|
|
|
Returns an HTML string containing a small representation of the page template.
|
|
|
|
=over
|
|
|
|
=item templateId
|
|
|
|
The id of the page template you wish to draw.
|
|
|
|
=back
|
|
|
|
=cut
|
|
|
|
sub drawTemplate {
|
|
my $template = getTemplate($_[0]);
|
|
$template =~ s/\n//g;
|
|
$template =~ s/\r//g;
|
|
$template =~ s/\'/\\\'/g;
|
|
$template = WebGUI::Macro::negate($template);
|
|
$template =~ s/\<script.*?\>.*?\<\/script\>//gi;
|
|
$template =~ s/\<table.*?\>/\<table cellspacing=0 cellpadding=3 width=100 height=80 border=1\>/ig;
|
|
$template =~ s/\<tmpl_loop\s+position(\d+)\_loop\>.*?\<\/tmpl\_loop\>/$1/ig;
|
|
return $template;
|
|
}
|
|
|
|
|
|
#-------------------------------------------------------------------
|
|
|
|
=head2 generate ( )
|
|
|
|
Generates the content of the page.
|
|
|
|
=cut
|
|
|
|
sub generate {
|
|
return WebGUI::Privilege::noAccess() unless (WebGUI::Privilege::canViewPage());
|
|
my %var;
|
|
$var{'page.canEdit'} = WebGUI::Privilege::canEditPage();
|
|
$var{'page.controls'} = pageIcon()
|
|
.deleteIcon('op=deletePage')
|
|
.editIcon('op=editPage')
|
|
.moveUpIcon('op=movePageUp')
|
|
.moveDownIcon('op=movePageDown')
|
|
.cutIcon('op=cutPage');
|
|
my $sth = WebGUI::SQL->read("select * from wobject where pageId=".$session{page}{pageId}." order by sequenceNumber, wobjectId");
|
|
while (my $wobject = $sth->hashRef) {
|
|
my $wobjectToolbar = wobjectIcon()
|
|
.deleteIcon('func=delete&wid='.${$wobject}{wobjectId})
|
|
.editIcon('func=edit&wid='.${$wobject}{wobjectId})
|
|
.moveUpIcon('func=moveUp&wid='.${$wobject}{wobjectId})
|
|
.moveDownIcon('func=moveDown&wid='.${$wobject}{wobjectId})
|
|
.moveTopIcon('func=moveTop&wid='.${$wobject}{wobjectId})
|
|
.moveBottomIcon('func=moveBottom&wid='.${$wobject}{wobjectId})
|
|
.cutIcon('func=cut&wid='.${$wobject}{wobjectId})
|
|
.copyIcon('func=copy&wid='.${$wobject}{wobjectId});
|
|
if (${$wobject}{namespace} ne "WobjectProxy" && isIn("WobjectProxy",@{$session{config}{wobjects}})) {
|
|
$wobjectToolbar .= shortcutIcon('func=createShortcut&wid='.${$wobject}{wobjectId});
|
|
}
|
|
if (${$wobject}{namespace} eq "WobjectProxy") {
|
|
my $originalWobject = $wobject;
|
|
my ($wobjectProxy) = WebGUI::SQL->quickHashRef("select * from WobjectProxy where wobjectId=".${$wobject}{wobjectId});
|
|
$wobject = WebGUI::SQL->quickHashRef("select * from wobject where wobject.wobjectId=".$wobjectProxy->{proxiedWobjectId});
|
|
if (${$wobject}{namespace} eq "") {
|
|
$wobject = $originalWobject;
|
|
} else {
|
|
${$wobject}{startDate} = ${$originalWobject}{startDate};
|
|
${$wobject}{endDate} = ${$originalWobject}{endDate};
|
|
${$wobject}{templatePosition} = ${$originalWobject}{templatePosition};
|
|
${$wobject}{_WobjectProxy} = ${$originalWobject}{wobjectId};
|
|
if ($wobjectProxy->{overrideTitle}) {
|
|
${$wobject}{title} = ${$originalWobject}{title};
|
|
}
|
|
if ($wobjectProxy->{overrideDisplayTitle}) {
|
|
${$wobject}{displayTitle} = ${$originalWobject}{displayTitle};
|
|
}
|
|
if ($wobjectProxy->{overrideDescription}) {
|
|
${$wobject}{description} = ${$originalWobject}{description};
|
|
}
|
|
if ($wobjectProxy->{overrideTemplate}) {
|
|
${$wobject}{templateId} = $wobjectProxy->{proxiedTemplateId};
|
|
}
|
|
}
|
|
}
|
|
my $cmd = "WebGUI::Wobject::".${$wobject}{namespace};
|
|
my $w = eval{$cmd->new($wobject)};
|
|
WebGUI::ErrorHandler::fatalError("Couldn't instanciate wobject: ${$wobject}{namespace}. Root cause: ".$@) if($@);
|
|
push(@{$var{'position'.$wobject->{templatePosition}.'_loop'}},{
|
|
'wobject.canView'=>WebGUI::Privilege::canViewWobject($wobject->{wobjectId}),
|
|
'wobject.canEdit'=>WebGUI::Privilege::canEditWobject($wobject->{wobjectId}),
|
|
'wobject.controls'=>$wobjectToolbar,
|
|
'wobject.controls.drag'=>dragIcon(),
|
|
'wobject.namespace'=>$wobject->{namespace},
|
|
'wobject.id'=>$wobject->{wobjectId},
|
|
'wobject.isInDateRange'=>$w->inDateRange,
|
|
'wobject.content'=>eval{$w->www_view}
|
|
});
|
|
WebGUI::ErrorHandler::fatalError("Wobject runtime error: ${$wobject}{namespace}. Root cause: ".$@) if($@);
|
|
}
|
|
$sth->finish;
|
|
return WebGUI::Template::process(getTemplate(),\%var);
|
|
}
|
|
|
|
|
|
#-------------------------------------------------------------------
|
|
=head2 getTemplateList
|
|
|
|
Returns a hash reference containing template ids and template titles for all the page templates available in the system.
|
|
|
|
=cut
|
|
|
|
sub getTemplateList {
|
|
return WebGUI::Template::getList("page");
|
|
}
|
|
|
|
#-------------------------------------------------------------------
|
|
=head2 getTemplate ( [ templateId ] )
|
|
|
|
Returns an HTML template.
|
|
|
|
=over
|
|
|
|
=item templateId
|
|
|
|
The id of the page template you wish to retrieve. Defaults to the current page's template id.
|
|
|
|
=back
|
|
|
|
=cut
|
|
|
|
sub getTemplate {
|
|
my $templateId = $_[0] || $session{page}{templateId};
|
|
return WebGUI::Template::get($templateId,"page");
|
|
}
|
|
|
|
#-------------------------------------------------------------------
|
|
=head2 getTemplatePositions ( templateId )
|
|
|
|
Returns a hash reference containing the positions available in the specified page template.
|
|
|
|
=over
|
|
|
|
=item templateId
|
|
|
|
The id of the page template you wish to retrieve the positions from.
|
|
|
|
=back
|
|
|
|
=cut
|
|
|
|
sub getTemplatePositions {
|
|
my (%hash, $template, $i);
|
|
tie %hash, "Tie::IxHash";
|
|
for ($i=1; $i<=countTemplatePositions($_[0]); $i++) {
|
|
$hash{$i} = $i;
|
|
}
|
|
return \%hash;
|
|
}
|
|
|
|
#-------------------------------------------------------------------
|
|
=head2 makeUnique ( pageURL, pageId )
|
|
|
|
Returns a unique page URL.
|
|
|
|
=over
|
|
|
|
=item url
|
|
|
|
The URL you're hoping for.
|
|
|
|
=item pageId
|
|
|
|
The page id of the page you're creating a URL for.
|
|
|
|
=back
|
|
|
|
=cut
|
|
|
|
sub makeUnique {
|
|
my ($url, $test, $pageId);
|
|
$url = $_[0];
|
|
$pageId = $_[1] || "new";
|
|
while (($test) = WebGUI::SQL->quickArray("select urlizedTitle from page where urlizedTitle='$url' and pageId<>'$pageId'")) {
|
|
if ($url =~ /(.*)(\d+$)/) {
|
|
$url = $1.($2+1);
|
|
} elsif ($test ne "") {
|
|
$url .= "2";
|
|
}
|
|
}
|
|
return $url;
|
|
}
|
|
|
|
#-------------------------------------------------------------------
|
|
=head2 getPage ( [pageId] )
|
|
|
|
This method fetches a WebGUI::Page object. If no pageId is given the current page will be used.
|
|
|
|
=over
|
|
|
|
=item pageId
|
|
|
|
The id of the page requested.
|
|
|
|
=back
|
|
|
|
=cut
|
|
sub getPage {
|
|
my ($cache, $pageLookup, $node, $self, $pageId, $tree, $pageInBranche);
|
|
($self, $pageId) = @_;
|
|
|
|
unless (defined $pageId) {
|
|
$pageId = $session{page}{pageId};
|
|
}
|
|
|
|
WebGUI::ErrorHandler::fatalError("Illegal pageId: '$pageId'") unless ($pageId =~ /^-?\d+$/);
|
|
|
|
# Fetch the correct pagetree from cache
|
|
$cache = WebGUI::Cache->new('root-0','PageTree-'.$session{config}{configFile});
|
|
$tree = $cache->getDataStructure;
|
|
|
|
# If the tree is cached then use it.
|
|
if (defined $tree) {
|
|
$node = $tree->{$pageId};
|
|
}
|
|
# If the tree isn't cached or if the requested page is not in the cached tree, recache.
|
|
if (!defined $tree || !$node) {
|
|
# Handle cache miss. The way it's done here costs twice the amount of time that's needed to build
|
|
# a tree. This shouldn't matter that much, though, since cache-misses should occur almost never.
|
|
WebGUI::Page->recachePageTree;
|
|
$node = WebGUI::Page->getTree()->{$pageId};
|
|
undef $pageInBranche;
|
|
}
|
|
|
|
# If there's still no page in node something's really wrong.
|
|
if (!$node) {
|
|
WebGUI::ErrorHandler::fatalError("Page is not in database! pageId: $pageId");
|
|
}
|
|
|
|
return $node;
|
|
}
|
|
|
|
#-------------------------------------------------------------------
|
|
=head2 move( newMother )
|
|
|
|
Moves a page to another page (ie. makes the page you execute this method on a child of newMother).
|
|
Returns 1 if the move was succesfull, 0 otherwise.
|
|
|
|
=over
|
|
|
|
=item newMother
|
|
|
|
The page under which the current page should be moved. This should be an WebGUI::Page object.
|
|
|
|
=back
|
|
|
|
=cut
|
|
sub move{
|
|
my ($self, $clipboard, $parentId, $newSequenceNumber, @newSisters, $newMother);
|
|
($self, $newMother) = @_;
|
|
|
|
# Avoid cyclic pages. Not doing this will allow people to freeze your computer, by generating infinite loops.
|
|
return 0 if (isIn($self->get("pageId"), map {$_->get("pageId")} $newMother->ancestors));
|
|
|
|
# Make sure a page is not moved to itself.
|
|
return 0 if ($self->get("pageId") == $newMother->get("pageId"));
|
|
|
|
$parentId = $self->get("parentId");
|
|
|
|
# Lower the sequence numbers of the following sisters
|
|
foreach ($self->right_sisters) {
|
|
$_->setWithoutRecache({
|
|
sequenceNumber => $_->get('sequenceNumber') - 1
|
|
});
|
|
}
|
|
|
|
# Derive new sequenceNumber
|
|
@newSisters = $newMother->daughters;
|
|
$newSequenceNumber = 1;
|
|
$newSequenceNumber = $newSisters[scalar(@newSisters)-1]->get('sequenceNumber') +1 if (@newSisters);
|
|
|
|
# Do the move
|
|
$self->unlink_from_mother;
|
|
$newMother->add_daughter($self);
|
|
$self->set({
|
|
parentId => $newMother->get("pageId"),
|
|
sequenceNumber => $newSequenceNumber,
|
|
});
|
|
|
|
return 1;
|
|
}
|
|
|
|
#-------------------------------------------------------------------
|
|
=head2 paste( newMother )
|
|
|
|
Pastes a page under newMother.
|
|
|
|
=over
|
|
|
|
=item newMother
|
|
|
|
The page under which the current page should be pasted. This should be an WebGUI::Page object.
|
|
|
|
=back
|
|
|
|
=cut
|
|
sub paste{
|
|
my ($self, $newMother);
|
|
($self, $newMother) = @_;
|
|
return $self if ($self->get("pageId") == $newMother->get("pageId"));
|
|
return WebGUI::ErrorHandler::fatalError("You cannot paste a page that's not on the clipboard. parentId:".
|
|
$self->get("parentId").", pageId:".$self->get("pageId")) unless ($self->get("parentId") == 2);
|
|
|
|
# Place page in clipboard (pageId 2)
|
|
if ($self->move($newMother)) {
|
|
$self->set({
|
|
bufferUserId => 'NULL',
|
|
bufferDate => 'NULL',
|
|
bufferPrevId => 'NULL'
|
|
});
|
|
}
|
|
|
|
return $self;
|
|
}
|
|
|
|
#-------------------------------------------------------------------
|
|
=head2 purge
|
|
|
|
This purges this object from the tree and the database.
|
|
|
|
=back
|
|
|
|
=cut
|
|
sub purge {
|
|
my ($self, $currentPage, @pagesToPurge);
|
|
$self = shift;
|
|
|
|
# Never ever modify the tree hierarchy in a walk_down...
|
|
$self->walk_down({
|
|
callback => sub {
|
|
$currentPage = shift;
|
|
push(@pagesToPurge, $currentPage);
|
|
}
|
|
});
|
|
|
|
# ... do it afterwards.
|
|
foreach $currentPage (@pagesToPurge) {
|
|
$currentPage->SUPER::delete;
|
|
}
|
|
|
|
return "";
|
|
}
|
|
|
|
#-------------------------------------------------------------------
|
|
=head2 recachePageTree
|
|
|
|
This method fetches all pageroots from the database, builds their underlying trees and caches them. Additionally
|
|
this method creates a lookup table that connects a node to a root. This is done to avoid searching through all
|
|
page tree to find a specific node.
|
|
|
|
It should only be nescesarry to call this method when setWithoutRecache is used.
|
|
|
|
=cut
|
|
sub recachePageTree {
|
|
my ($forrest, @pageRoots, $currentTree, $serializer, $node, $serialized, $cache, %pageLookup);
|
|
|
|
# Purge the cached page trees.
|
|
$cache = WebGUI::Cache->new("", "PageTree-".$session{config}{configFile});
|
|
$cache->deleteByRegex(".*");
|
|
|
|
# Fetch the complete forrest, which is actually all the pagetrees connected by a dummy root.
|
|
$forrest = WebGUI::Page->getTree();
|
|
|
|
# Cache complete forrest.
|
|
$cache = WebGUI::Cache->new('root-0','PageTree-'.$session{config}{configFile});
|
|
$cache->setDataStructure($forrest);
|
|
|
|
return "";
|
|
}
|
|
|
|
#-------------------------------------------------------------------
|
|
=head2 set ( [ data ] )
|
|
|
|
If data is given, invoking this method will set the object to the state given in data. If called without any arguments
|
|
the state of the tree is saved to the database.
|
|
|
|
A thing to note here is that the cached version of the pagetree is always refreshed after saving to the database. Refreshing
|
|
the cache is pretty expensive, so if you have to do many sets in a row, like when recursively changing style of a (sub)tree,
|
|
it would be best to use setWithoutRecache, and call recachePageTree afterwards.
|
|
|
|
=over
|
|
|
|
=item data
|
|
|
|
The properties you want to set. This parameter is optional and should be a hashref of the form {propertyA => valueA, propertyB => valueB, etc...}
|
|
|
|
=back
|
|
|
|
=cut
|
|
sub set {
|
|
my $self = shift;
|
|
my $output = $self->SUPER::set(@_);
|
|
|
|
# The very only reason we overload the set method is to make sure that the cache also gets
|
|
# updated. So let's do just that ;). This might be overkill for some situations where only
|
|
# one tree needs to be updated, but doing all of them, sure is a lot safer. (and easier!)
|
|
recachePageTree();
|
|
|
|
return $output;
|
|
}
|
|
|
|
#-------------------------------------------------------------------
|
|
=head2 setWithoutRecache ([data])
|
|
|
|
See set. The only difference with set is that the cached version of the pagetree is not updated. This means that you must
|
|
update it manually by invoking recachePageTree afterwards.
|
|
|
|
=over
|
|
|
|
=item data
|
|
|
|
The properties you want to set. This parameter is optional and should be a hashref of the form {propertyA => valueA, propertyB => valueB, etc...}
|
|
|
|
=back
|
|
|
|
=cut
|
|
sub setWithoutRecache {
|
|
my $self = shift;
|
|
return $self->SUPER::set(@_);
|
|
}
|
|
|
|
1;
|