596 lines
21 KiB
Perl
596 lines
21 KiB
Perl
package WebGUI::Wobject::IndexedSearch;
|
|
|
|
use strict;
|
|
use Time::HiRes;
|
|
use WebGUI::Wobject::IndexedSearch::Search;
|
|
use WebGUI::HTMLForm;
|
|
use WebGUI::HTML;
|
|
use WebGUI::Macro;
|
|
use WebGUI::International;
|
|
use WebGUI::Session;
|
|
use WebGUI::SQL;
|
|
use WebGUI::Wobject;
|
|
use Tie::IxHash;
|
|
use WebGUI::Utility;
|
|
use WebGUI::Paginator;
|
|
use WebGUI::Page;
|
|
|
|
our @ISA = qw(WebGUI::Wobject);
|
|
|
|
#-------------------------------------------------------------------
|
|
sub name {
|
|
return WebGUI::International::get(17,$_[0]->get("namespace"));
|
|
}
|
|
|
|
#-------------------------------------------------------------------
|
|
sub new {
|
|
my $class = shift;
|
|
my $property = shift;
|
|
my $self = WebGUI::Wobject->new(
|
|
-useTemplate=>1,
|
|
-useMetaData=>1,
|
|
-properties=>$property,
|
|
-extendedProperties=>{
|
|
indexName=>{
|
|
defaultValue=>'default'
|
|
},
|
|
searchRoot=>{
|
|
fieldType=>'checkList',
|
|
defaultValue=>'any'
|
|
},
|
|
forceSearchRoots=>{
|
|
fieldType=>'yesNo',
|
|
defaultValue=>1
|
|
},
|
|
users=>{
|
|
fieldType=>'selectList',
|
|
defaultValue=>'any'
|
|
},
|
|
namespaces=>{
|
|
fieldType=>'selectList',
|
|
defaultValue=>'any'
|
|
},
|
|
languages=>{
|
|
fieldType=>'selectList',
|
|
defaultValue=>'any'
|
|
},
|
|
contentTypes=>{
|
|
fieldType=>'selectList',
|
|
defaultValue=>'any'
|
|
},
|
|
paginateAfter=>{
|
|
defaultValue=>10
|
|
},
|
|
highlight=>{
|
|
defaultValue=>1
|
|
},
|
|
previewLength=>{
|
|
defaultValue=>130
|
|
},
|
|
highlight_1=>{
|
|
defaultValue=>'#ffff66'
|
|
},
|
|
highlight_2=>{
|
|
defaultValue=>'#A0FFFF'
|
|
},
|
|
highlight_3=>{
|
|
defaultValue=>'#99ff99'
|
|
},
|
|
highlight_4=>{
|
|
defaultValue=>'#ff9999'
|
|
},
|
|
highlight_5=>{
|
|
defaultValue=>'#ff66ff'
|
|
},
|
|
}
|
|
);
|
|
bless $self, $class;
|
|
}
|
|
|
|
#-------------------------------------------------------------------
|
|
sub uiLevel {
|
|
return 5;
|
|
}
|
|
|
|
#-------------------------------------------------------------------
|
|
sub www_edit {
|
|
my $self = shift;
|
|
my (@data, %indexName);
|
|
|
|
tie my %searchRoot, 'Tie::IxHash';
|
|
|
|
my $layout = WebGUI::HTMLForm->new;
|
|
my $properties = WebGUI::HTMLForm->new;
|
|
my $privileges = WebGUI::HTMLForm->new;
|
|
|
|
# Unconditional read to catch intallation errors.
|
|
my $sth = WebGUI::SQL->unconditionalRead("select distinct(indexName), indexName from IndexedSearch_docInfo");
|
|
unless ($sth->errorCode < 1) {
|
|
return "<p><b>" . WebGUI::International::get(1,$self->get("namespace")) . $sth->errorMessage."</b></p>";
|
|
}
|
|
while (@data = $sth->array) {
|
|
$indexName{$data[0]} = $data[1];
|
|
}
|
|
$sth->finish;
|
|
unless(%indexName) {
|
|
return "<p><b>" . WebGUI::International::get(2,$self->get("namespace")) .
|
|
"<p>" . WebGUI::International::get(3,$self->get("namespace")) . "</b></p>";
|
|
}
|
|
|
|
# Index to use
|
|
# $properties->radioList( -name=>'indexName',
|
|
# -options=>\%indexName,
|
|
# -label=>WebGUI::International::get(5,$self->get("namespace")),
|
|
# -value=>$self->getValue("indexName"),
|
|
# -vertical=>1
|
|
# );
|
|
# NOTE: For now we're limiting each site to one index. Will allow more in the future.
|
|
$properties->hidden(
|
|
-name=>"indexName",
|
|
-value=>"IndexedSearch_default"
|
|
);
|
|
|
|
# Page roots
|
|
%searchRoot = ( 'any'=>WebGUI::International::get(15,$self->get("namespace")),
|
|
$session{page}{pageId}=>WebGUI::International::get(4,$self->get("namespace")),
|
|
WebGUI::SQL->buildHash("select pageId,title from page where parentId='0' and isSystem<>'1' order by title")
|
|
);
|
|
$properties->checkList ( -name=>'searchRoot',
|
|
-options=>\%searchRoot,
|
|
-label=>WebGUI::International::get(6,$self->get("namespace")),
|
|
-value=>[ split("\n", $self->getValue("searchRoot")) ],
|
|
-multiple=>1,
|
|
-vertical=>1,
|
|
);
|
|
$properties->yesNo(
|
|
-name=>'forceSearchRoots',
|
|
-label=>WebGUI::International::get('edit-forceSearchRoots-label',$self->get("namespace")),
|
|
-value=>$self->getValue("forceSearchRoots")
|
|
);
|
|
# Content of specific user
|
|
$properties->selectList ( -name=>'users',
|
|
-options=>$self->_getUsers(),
|
|
-label=>WebGUI::International::get(7,$self->get("namespace")),
|
|
-value=>[ split("\n", $self->getValue("users")) ],
|
|
-multiple=>1,
|
|
-size=>5
|
|
);
|
|
|
|
# Content in specific namespaces
|
|
$properties->selectList ( -name=>'namespaces',
|
|
-options=>$self->_getNamespaces,
|
|
-label=>WebGUI::International::get(8,$self->get("namespace")),
|
|
-value=>[ split("\n", $self->getValue("namespaces")) ],
|
|
-multiple=>1,
|
|
-size=>5
|
|
);
|
|
|
|
# Content in specific language
|
|
$properties->checkList ( -name=>'languages',
|
|
-options=>$self->_getLanguages(),
|
|
-label=>WebGUI::International::get(9,$self->get("namespace")),
|
|
-value=>[ split("\n", $self->getValue("languages")) ],
|
|
-multiple=>1,
|
|
);
|
|
|
|
# Only specific content types
|
|
my $contentTypes = $self->_getContentTypes();
|
|
delete $contentTypes->{content};
|
|
$properties->checkList ( -name=>'contentTypes',
|
|
-options=>$contentTypes,
|
|
-label=>WebGUI::International::get(10,$self->get("namespace")),
|
|
-value=>[ split("\n", $self->getValue("contentTypes")) ],
|
|
-multiple=>1,
|
|
-vertical=>1,
|
|
);
|
|
$layout->integer ( -name=>'paginateAfter',
|
|
-label=>WebGUI::International::get(11,$self->get("namespace")),
|
|
-value=>$self->getValue("paginateAfter"),
|
|
);
|
|
$layout->integer ( -name=>'previewLength',
|
|
-label=>WebGUI::International::get(12,$self->get("namespace")),
|
|
-value=>$self->getValue("previewLength"),
|
|
);
|
|
$layout->yesNo ( -name=>'highlight',
|
|
-label=>WebGUI::International::get(13,$self->get("namespace")),
|
|
-value=>$self->getValue("highlight"),
|
|
);
|
|
|
|
# Color picker for highlight colors
|
|
$layout->raw ( -value=>'
|
|
<SCRIPT LANGUAGE="Javascript" SRC="'.$session{config}{extrasURL}.'/wobject/IndexedSearch/ColorPicker2.js"></SCRIPT>
|
|
<SCRIPT LANGUAGE="JavaScript">
|
|
var cp = new ColorPicker("window");
|
|
</SCRIPT>'
|
|
);
|
|
for (1..5) {
|
|
my $highlight = "highlight_$_";
|
|
$layout->text ( -name=>$highlight,
|
|
-label=>WebGUI::International::get(14,$self->get("namespace")) ." $_:",
|
|
-size=>7,
|
|
-value=>$self->getValue($highlight),
|
|
-subtext=>qq{
|
|
<A HREF="#" onClick="cp.select($highlight,'$highlight');
|
|
return false;" NAME="$highlight" ID="$highlight">Pick</A>}
|
|
);
|
|
}
|
|
|
|
return $self->SUPER::www_edit(
|
|
-properties=>$properties->printRowsOnly,
|
|
-layout=>$layout->printRowsOnly,
|
|
-privileges=>$privileges->printRowsOnly,
|
|
-heading=>"Edit Search",
|
|
-helpId=>"search add/edit"
|
|
);
|
|
|
|
}
|
|
|
|
#-------------------------------------------------------------------
|
|
sub www_view {
|
|
my $self = shift;
|
|
$self->logView() if ($session{setting}{passiveProfilingEnabled});
|
|
my (%var, @resultsLoop);
|
|
|
|
# Do some query handling
|
|
$var{exactPhrase} = $session{form}{exactPhrase};
|
|
$var{allWords} = $session{form}{allWords};
|
|
$var{atLeastOne} = $session{form}{atLeastOne};
|
|
$var{without} = $session{form}{without};
|
|
$var{query} = $session{form}{query};
|
|
$var{query} .= qq{ +"$var{exactPhrase}"} if ($var{exactPhrase});
|
|
$var{query} .= " ".join(" ",map("+".$_,split(/\s+/,$var{allWords}))) if ($var{allWords});
|
|
$var{query} .= qq{ $var{atLeastOne}} if ($var{atLeastOne});
|
|
$var{query} .= " ".join(" ",map("-".$_,split(/\s+/,$var{without}))) if ($var{without});
|
|
|
|
# Remove macro's from query
|
|
$var{query} = WebGUI::Macro::negate($var{query});
|
|
|
|
# Set some standard vars
|
|
$var{submit} = WebGUI::Form::submit({value=>WebGUI::International::get(16, $self->get("namespace"))});
|
|
$var{"int.search"} = WebGUI::International::get(16,$self->get("namespace"));
|
|
$var{wid} = $self->get("wobjectId");
|
|
$var{numberOfResults} = '0';
|
|
$var{"select_".$self->getValue("paginateAfter")} = "selected";
|
|
|
|
# Do the search
|
|
my $startTime = Time::HiRes::time();
|
|
my $filter = $self->_buildFilter;
|
|
my $search = WebGUI::Wobject::IndexedSearch::Search->new($self->getValue('indexName'));
|
|
$search->open;
|
|
my $results = $search->search($var{query},$filter);
|
|
$var{duration} = Time::HiRes::time() - $startTime;
|
|
$var{duration} = sprintf("%.3f", $var{duration}); # Duration rounded to 3 decimal places
|
|
# Let's see if the search returned any results
|
|
if (defined ($results)) {
|
|
$var{numberOfResults} = scalar(@$results);
|
|
|
|
# Deal with pagination
|
|
my $url = "wid=".$self->get("wobjectId")."&func=view&query=".WebGUI::URL::escape($var{query});
|
|
map {$url .= "&users=".WebGUI::URL::escape($_)} $session{cgi}->param('users');
|
|
map {$url .= "&namespaces=".WebGUI::URL::escape($_)} $session{cgi}->param('namespaces');
|
|
map {$url .= "&languages=".WebGUI::URL::escape($_)} $session{cgi}->param('languages');
|
|
map {$url .= "&contentTypes=".WebGUI::URL::escape($_)} $session{cgi}->param('contentTypes');
|
|
$url .= "&paginateAfter=".$self->getValue("paginateAfter");
|
|
my $p = WebGUI::Paginator->new(WebGUI::URL::page($url), $self->getValue("paginateAfter"));
|
|
$p->setDataByArrayRef($results);
|
|
$var{startNr} = 1;
|
|
if($session{form}{pn}) {
|
|
$var{startNr} = (($session{form}{pn} - 1) * $self->getValue("paginateAfter")) + 1;
|
|
}
|
|
|
|
my @highlightColors = map { $self->getValue("highlight_$_") } (1..5);
|
|
$var{queryHighlighted} = $search->highlight($var{query}, undef, \@highlightColors);
|
|
|
|
# Get result details for this page
|
|
if($p->getPageNumber > $p->getNumberOfPages) {
|
|
$var{numberOfResults} = 0;
|
|
$var{resultsLoop} = [];
|
|
} else {
|
|
$var{resultsLoop} = $search->getDetails($p->getPageData,
|
|
highlightColors => \@highlightColors,
|
|
previewLength => $self->getValue('previewLength'),
|
|
highlight => $self->getValue('highlight')
|
|
);
|
|
# Pagination variables
|
|
$var{endNr} = $var{startNr}+(scalar(@{$var{resultsLoop}}))-1;
|
|
$p->appendTemplateVars(\%var);
|
|
}
|
|
}
|
|
|
|
# Create a loop with namespaces
|
|
$var{namespaces} = [];
|
|
my $namespaces = $self->_getNamespaces('restricted');
|
|
foreach(keys %$namespaces) {
|
|
my $selected = 0;
|
|
if (scalar $session{cgi}->param('namespaces')) {
|
|
$selected = isIn($_, $session{cgi}->param('namespaces'));
|
|
} else {
|
|
$selected = ($session{form}{namespaces} =~ /$_/);
|
|
}
|
|
push(@{$var{namespaces}}, { value => $_, name => $namespaces->{$_}, selected => $selected });
|
|
}
|
|
|
|
# Create a loop with contentTypes
|
|
#
|
|
# And while we are busy we also create a loop with simplified contentTypes
|
|
# This means: wobject, page, wobjectDetail are masked in one option: content
|
|
|
|
$var{contentTypes} = [];
|
|
$var{contentTypesSimple} = [];
|
|
my $contentTypes = $self->_getContentTypes('restricted');
|
|
foreach(keys %$contentTypes) {
|
|
my $selected = 0;
|
|
if (scalar $session{cgi}->param('contentTypes')) {
|
|
$selected = isIn($_, $session{cgi}->param('contentTypes'));
|
|
} else {
|
|
$selected = ($session{form}{contentTypes} =~ /$_/);
|
|
}
|
|
unless(/^content$/) { # No shortcut in the detailed contentType list
|
|
push(@{$var{contentTypes}}, { value => $_,
|
|
name => $contentTypes->{$_},
|
|
selected => $selected,
|
|
'type_'.$_ => 1 });
|
|
}
|
|
unless(/^page|wobject|wobjectDetail$/) { # No details in the simple contentType list
|
|
push(@{$var{contentTypesSimple}}, { value => $_,
|
|
name => $contentTypes->{$_},
|
|
selected => $selected,
|
|
'type_'.$_ => 1 });
|
|
}
|
|
}
|
|
|
|
# Create a loop with users
|
|
$var{users} = [];
|
|
my $users = $self->_getUsers('restricted');
|
|
foreach(keys %$users) {
|
|
my $selected = 0;
|
|
if (scalar $session{cgi}->param('users')) {
|
|
$selected = isIn($_, $session{cgi}->param('users'));
|
|
} else {
|
|
$selected = ($session{form}{users} =~ /$_/);
|
|
}
|
|
push(@{$var{users}}, { value => $_, name => $users->{$_}, selected => $selected });
|
|
}
|
|
|
|
# Create a loop with languages
|
|
$var{languages} = [];
|
|
my $languages = $self->_getLanguages('restricted');
|
|
foreach(keys %$languages) {
|
|
my $selected = 0;
|
|
if (scalar $session{cgi}->param('languages')) {
|
|
$selected = isIn($_, $session{cgi}->param('languages'));
|
|
} else {
|
|
$selected = ($session{form}{languages} =~ /$_/);
|
|
}
|
|
push(@{$var{languages}}, { value => $_, name => $languages->{$_}, selected => $selected });
|
|
}
|
|
|
|
# Create a loop with searchable page roots
|
|
my $rootData;
|
|
my @roots = split(/\n/, $self->get('searchRoot'));
|
|
my %checked = map {$_=>1} $session{cgi}->param("searchRoot");
|
|
if (isIn('any', @roots)) {
|
|
foreach $rootData (WebGUI::Page->getAnonymousRoot->daughters) {
|
|
push (@{$var{searchRoots}}, {
|
|
value => $rootData->{'pageId'},
|
|
menuTitle => $rootData->{'menuTitle'},
|
|
title => $rootData->{'title'},
|
|
urlizedTitle => $rootData->{'urlizedTitle'},
|
|
checked => $checked{$rootData->{'pageId'}},
|
|
});
|
|
$var{"rootPage.".$rootData->{'urlizedTitle'}.".id"} = $rootData->{'pageId'};
|
|
$var{"rootPage.".$rootData->{'urlizedTitle'}.".checked"} = $checked{$rootData->{'pageId'}};
|
|
}
|
|
} else {
|
|
foreach (@roots) {
|
|
$rootData = WebGUI::Page->new($_);
|
|
push (@{$var{searchRoots}}, {
|
|
value => $rootData->get('pageId'),
|
|
menuTitle => $rootData->get('menuTitle'),
|
|
title => $rootData->get('title'),
|
|
urlizedTitle => $rootData->get('urlizedTitle'),
|
|
checked => $checked{$rootData->get('pageId')},
|
|
});
|
|
$var{"rootPage.".$rootData->get('urlizedTitle').".id"} = $rootData->get('pageId');
|
|
$var{"rootPage.".$rootData->get('urlizedTitle').".checked"} = $checked{$rootData->get('pageId')};
|
|
}
|
|
}
|
|
$var{"anyRootPage.checked"} = $checked{'any'};
|
|
# close the search
|
|
$search->close;
|
|
|
|
return $self->processTemplate($self->get("templateId"),\%var);
|
|
}
|
|
|
|
#-------------------------------------------------------------------
|
|
sub _buildPageList {
|
|
my ($self, @userSpecifiedRoots, @roots, @allowedRoots, $pageId, @pages);
|
|
$self = shift;
|
|
|
|
@userSpecifiedRoots = $session{cgi}->param("searchRoot");
|
|
|
|
if ((scalar(@userSpecifiedRoots) == 0)
|
|
|| ($self->getValue("forceSearchRoots"))
|
|
|| (isIn('any', @userSpecifiedRoots))
|
|
) {
|
|
@roots = split(/\n+/i, $self->get("searchRoot"));
|
|
} else {
|
|
@allowedRoots = split(/\n+/, $self->get("searchRoot"));
|
|
|
|
foreach (@userSpecifiedRoots) {
|
|
push (@roots, $_) if (isIn($_, @allowedRoots));
|
|
}
|
|
}
|
|
foreach $pageId (@roots) {
|
|
WebGUI::Page->new($pageId)->traversePreOrder(
|
|
sub {
|
|
push(@pages, $_[0]->get('pageId'));
|
|
}
|
|
);
|
|
}
|
|
|
|
return [ @pages ];
|
|
}
|
|
|
|
#-------------------------------------------------------------------
|
|
sub _buildFilter {
|
|
my $self = shift;
|
|
my %filter = ();
|
|
|
|
# pages
|
|
if($self->get('searchRoot') !~ /any/i) {
|
|
$filter{pageId} = $self->_buildPageList;
|
|
}
|
|
|
|
# languages
|
|
if($session{form}{languages} && ! isIn('any', $session{cgi}->param('languages'))) {
|
|
$filter{languageId} = [ $session{cgi}->param('languages') ];
|
|
} elsif ($self->getValue('languages') !~ /any/i) {
|
|
$filter{languageId} = [ split(/\n/, $self->getValue('languages')) ];
|
|
}
|
|
push(@{$filter{languageId}}, '0') if (exists $filter{languageId}); # Some content (i.e. profiles)
|
|
# don't have a language. They
|
|
# must be found as well.
|
|
|
|
# content-types
|
|
if($session{form}{contentTypes} && ! isIn('any', $session{cgi}->param('contentTypes'))) {
|
|
$filter{contentType} = [ $session{cgi}->param('contentTypes') ];
|
|
|
|
# contentType "content" is a shortcut for "page", "wobject" and "wobjectDetail"
|
|
if (isIn('content', $session{cgi}->param('contentTypes'))) {
|
|
push(@{$filter{contentType}}, qw/page wobject wobjectDetail/);
|
|
}
|
|
} elsif ($self->getValue('contentTypes') !~ /any/i) {
|
|
$filter{contentType} = [ split(/\n/, $self->getValue('contentTypes')) ];
|
|
}
|
|
|
|
# users
|
|
if($session{form}{users} && ! isIn('any', $session{cgi}->param('users'))) {
|
|
$filter{ownerId} = [];
|
|
foreach my $user ($session{cgi}->param('users')) {
|
|
if ($user =~ /\D/) {
|
|
$user =~ s/\*/%/g;
|
|
($user) = WebGUI::SQL->buildArray("select userId from users where username like ".quote($user));
|
|
}
|
|
push(@{$filter{ownerId}}, quote($user)) if ($user =~ /^\d+$/);
|
|
}
|
|
} elsif ($self->getValue('users') !~ /any/i) {
|
|
$filter{ownerId} = [ split(/\n/, $self->getValue('users')) ];
|
|
}
|
|
|
|
# namespaces
|
|
if($session{form}{namespaces} && ! isIn('any', $session{cgi}->param('namespaces'))) {
|
|
$filter{namespace} = [ $session{cgi}->param('namespaces') ];
|
|
} elsif ($self->getValue('namespaces') !~ /any/i) {
|
|
$filter{namespace} = [ split(/\n/, $self->getValue('namespaces')) ];
|
|
}
|
|
|
|
# delete $filter{ownerId} if it is an empty array reference
|
|
if(exists($filter{ownerId})) {
|
|
delete $filter{ownerId} unless (scalar(@{$filter{ownerId}}));
|
|
}
|
|
return \%filter;
|
|
}
|
|
|
|
#-------------------------------------------------------------------
|
|
sub _getLanguages {
|
|
my ($self, $restricted) = @_;
|
|
my $international = WebGUI::SQL->buildHashRef("select distinct(languageId) from IndexedSearch_docInfo");
|
|
tie my %languages, 'Tie::IxHash';
|
|
if ($restricted and $self->get('languages') !~ /any/i) {
|
|
$languages{any} = WebGUI::International::get(24,$self->get("namespace"));
|
|
foreach (split/\n/, $self->get('languages')) {
|
|
$languages{$_} = $international->{$_};
|
|
}
|
|
} else {
|
|
%languages = ('any' => WebGUI::International::get(24,$self->get("namespace")) , %$international);
|
|
}
|
|
return \%languages;
|
|
}
|
|
|
|
#-------------------------------------------------------------------
|
|
sub _getNamespaces {
|
|
my ($self, $restricted) = @_;
|
|
my %international;
|
|
foreach my $wobject (@{$session{config}{wobjects}}){
|
|
my $cmd = "WebGUI::Wobject::".$wobject;
|
|
my $load = 'use '.$cmd;
|
|
eval($load);
|
|
WebGUI::ErrorHandler::warn("Wobject failed to compile: $cmd.".$@) if($@);
|
|
my $w = $cmd->new({namespace=>$wobject, wobjectId=>'new'});
|
|
$international{$wobject} = $w->name;
|
|
}
|
|
tie my %namespaces, 'Tie::IxHash';
|
|
if ($restricted and $self->get('namespaces') !~ /any/i) {
|
|
$namespaces{any} = WebGUI::International::get(18,$self->get("namespace"));
|
|
foreach (split/\n/, $self->get('namespaces')) {
|
|
$namespaces{$_} = $international{$_} || ucfirst($_);
|
|
}
|
|
} else {
|
|
$namespaces{any} = WebGUI::International::get(18,$self->get("namespace"));
|
|
foreach (WebGUI::SQL->buildArray("select distinct(namespace) from IndexedSearch_docInfo order by namespace")) {
|
|
$namespaces{$_} = $international{$_} ||ucfirst($_);
|
|
}
|
|
}
|
|
return \%namespaces;
|
|
}
|
|
|
|
#-------------------------------------------------------------------
|
|
sub _getContentTypes {
|
|
my ($self, $restricted) = @_;
|
|
my %international = ( 'page' => WebGUI::International::get(2),
|
|
'wobject' => WebGUI::International::get(19,$self->get("namespace")),
|
|
'wobjectDetail' => WebGUI::International::get(20,$self->get("namespace")),
|
|
'content' => WebGUI::International::get(21,$self->get("namespace")),
|
|
'discussion' => WebGUI::International::get(892),
|
|
'profile' => WebGUI::International::get(22,$self->get("namespace")),
|
|
'any' => WebGUI::International::get(23,$self->get("namespace")),
|
|
);
|
|
tie my %contentTypes, 'Tie::IxHash';
|
|
if ($restricted and $self->get('contentTypes') !~ /any/i) {
|
|
$contentTypes{any} = $international{any};
|
|
$contentTypes{content} = $international{content}; # shortcut for page, wobject and wobjectDetail
|
|
foreach (split/\n/, $self->get('contentTypes')) {
|
|
$contentTypes{$_} = $international{$_};
|
|
}
|
|
} else {
|
|
%contentTypes = ( 'any' => $international{any},
|
|
'content' => $international{content}, # shortcut for page, wobject and wobjectDetail
|
|
);
|
|
foreach (WebGUI::SQL->buildArray("select distinct(contentType) from IndexedSearch_docInfo order by contentType")) {
|
|
$contentTypes{$_} = $international{$_} || ucfirst($_);
|
|
}
|
|
}
|
|
return \%contentTypes;
|
|
}
|
|
|
|
#-------------------------------------------------------------------
|
|
sub _getSearchablePages {
|
|
my $searchRoot = shift;
|
|
my %pages;
|
|
my $sth = WebGUI::SQL->read("select pageId from page where parentId = ".quote($searchRoot));
|
|
while (my %data = $sth->hash) {
|
|
$pages{$data{pageId}} = 1;
|
|
%pages = (%pages, _getSearchablePages($data{pageId}) );
|
|
}
|
|
return %pages;
|
|
}
|
|
|
|
#-------------------------------------------------------------------
|
|
sub _getUsers {
|
|
my ($self, $restricted) = @_;
|
|
tie my %users, 'Tie::IxHash';
|
|
if ($restricted and $self->get('users') !~ /any/i) {
|
|
$users{any} = WebGUI::International::get(25,$self->get("namespace"));
|
|
foreach (split/\n/, $self->get('users')) {
|
|
$users{$_} = $_;
|
|
}
|
|
} else {
|
|
%users = ( 'any' => WebGUI::International::get(25,$self->get("namespace")),
|
|
WebGUI::SQL->buildHash("select userId, username from users order by username")
|
|
);
|
|
}
|
|
return \%users;
|
|
}
|
|
|
|
1;
|