oqapi/webgui
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merged versionTagMode support from amh development branch. Upgrade scripts not updated yet

Browse source
This commit is contained in:
Henry Tang 2008-11-13 17:03:47 +00:00
commit 2a3ed29d26
6 changed files with 349 additions and 48 deletions
Download patch file Download diff file Expand all files Collapse all files

9
lib/WebGUI/Auth.pm Normal file → Executable file
View file

@ -760,6 +760,8 @@ sub isVisitor {
Superclass method that performs standard login routines. This is what should happen after a user has been authenticated.
Authentication should always happen in the subclass routine.
Open version tag is reclaimed if user is in site wide or singlePerUser mode.
=cut
sub login {
@ -803,7 +805,12 @@ sub login {
$self->session->http->setRedirect($self->session->scratch->get("redirectAfterLogin"));
$self->session->scratch->delete("redirectAfterLogin");
}
# Get open version tag. This is needed if we want
# to reclaim a version right after login (singlePerUser and siteWide mode)
# and to have the correct version displayed.
WebGUI::VersionTag->getWorking($self->session(), q{noCreate});
return undef;
}

31
lib/WebGUI/Operation/Settings.pm Normal file → Executable file
View file

@ -80,14 +80,29 @@ sub definition {
label=>$i18n->get("default version tag workflow"),
hoverHelp=>$i18n->get('default version tag workflow help'),
});
push(@fields, {
tab=>"content",
fieldType=>"yesNo",
name=>"autoRequestCommit",
label=>$i18n->get("auto request commit"),
hoverHelp=>$i18n->get("auto request commit help"),
defaultValue=>$setting->get("autoRequestCommit")
});
# Support for versionTagMode. We'll have:
# - multi version tag per user
# - one version tag per user (SwiftySite mode)
# - one site wide version tag
# - auto commit
push (
@fields,
{ tab => q{content},
fieldType => q{selectBox},
name => q{versionTagMode},
defaultValue => [ $setting->get(q{versionTagMode}) ],
options => {
multiPerUser => $i18n->get(q{versionTagMode multiPerUser}),
singlePerUser => $i18n->get(q{versionTagMode singlePerUser}),
siteWide => $i18n->get(q{versionTagMode siteWide}),
autoCommit => $i18n->get(q{versionTagMode autoCommit}),
},
label => $i18n->get(q{version tag mode}),
hoverHelp => $i18n->get(q{version tag mode help}),
},
);
push(@fields, {
tab=>"content",
fieldType=>"yesNo",

0
lib/WebGUI/ProfileField.pm Normal file → Executable file
View file

184
lib/WebGUI/VersionTag.pm Normal file → Executable file
View file

@ -73,11 +73,14 @@ sub autoCommitWorkingIfEnabled {
my $versionTag = $class->getWorking($session, "nocreate");
return undef
unless $versionTag;
#Auto commit is no longer determined from autoRequestCommit
# auto commit assets
# save and commit button and site wide auto commit work the same
if (
$options->{override}
|| $session->setting->get("autoRequestCommit")
|| $class->getVersionTagMode($session) eq q{autoCommit}
) {
if ($session->setting->get("skipCommitComments") || !$options->{allowComments}) {
$versionTag->requestCommit;
@ -358,6 +361,35 @@ sub getRevisionCount {
}
#-------------------------------------------------------------------
=head2 getVersionTagMode ( session )
Return version tag mode for current session
=cut
sub getVersionTagMode {
my $class = shift;
my $session = shift;
my $mode = q{};
$mode = $session->user()->profileField(q{versionTagMode});
#verify mode.
if (!(defined $mode && WebGUI::Utility::isIn($mode, qw{autoCommit siteWide singlePerUser multiPerUser}))) {
$mode = q{};
}
#Get mode from settings
if ($mode eq q{}) {
$mode = $session->setting()->get(q{versionTagMode});
}
return $mode;
} #getVersionTagMode
#-------------------------------------------------------------------
=head2 getWorkflowInstance ( )
@ -388,26 +420,92 @@ A boolean that if set to true, will prevent this method from creating an autotag
=cut
sub getWorking {
my $class = shift;
my $session = shift;
my $noCreate = shift;
if ($session->stow->get("versionTag")) {
return $session->stow->get("versionTag");
} else {
my $tagId = $session->scratch->get("versionTag");
if ($tagId) {
my $tag = $class->new($session, $tagId);
$session->stow->set("versionTag",$tag);
return $tag;
} elsif ($noCreate) {
return undef;
} else {
my $tag = $class->create($session);
$tag->setWorking;
return $tag;
}
}
}
my $class = shift;
my $session = shift;
my $noCreate = shift;
my $stow = $session->stow();
my $mode = $class->getVersionTagMode($session);
my $tag;
my $tagId;
#First see if there is already a version tag
$tag = $stow->get(q{versionTag});
return $tag if $tag;
$tagId = $session->scratch()->get(q{versionTag});
if ($tagId) {
$tag = $class->new($session, $tagId);
$stow->set(q{versionTag}, $tag);
return $tag;
}
#No tag found. Create or reclaim one?
# multiPerUser / autoCommit: no reclaim, create if not noCreate
# singlePerUser: try to reclaim previous if only 1 open tag
# siteWide: try to claim site-wide version tag
# autoCommit:
if ($mode eq q{singlePerUser}) {
# Get all open tags for user. If only 1 tag open then reclaim
# it.
my @openTags = ();
my $userId = $session->user()->userId();
OPENTAG:
foreach my $openTag (@{WebGUI::VersionTag->getOpenTags($session)}) {
# Do not reclaim site wide tag in singlePerUser mode
next OPENTAG if $openTag->get(q{isSiteWide});
if ($openTag->get(q{createdBy}) eq $userId) {
push @openTags, $openTag;
}
}
# For now, we only reclaim if 1 tag open.
if (scalar @openTags == 1) {
$tag = $openTags[0];
$tag->setWorking();
return $tag;
}
}
elsif ($mode eq q{siteWide}) {
# Check for site wide version tag. Reclaim if available
OPENTAG:
foreach my $openTag (@{WebGUI::VersionTag->getOpenTags($session)}) {
if ($openTag->get(q{isSiteWide})) {
$tag = $openTag;
$tag->setWorking();
return $tag;
}
}
}
return undef if $noCreate;
# Create new tag.
my %properties = ();
if ($mode eq q{siteWide}) {
$properties{isSiteWide} = 1;
}
$tag = $class->create($session, \%properties);
$tag->setWorking();
return $tag;
} #getWorking
#-------------------------------------------------------------------
@ -553,17 +651,20 @@ The time that a version tag shoudl stop displaying on the website.
=cut
sub set {
my $self = shift;
my $properties = shift;
my $self = shift;
my $properties = shift;
my $now = $self->session->datetime->time();
my $startTime = WebGUI::DateTime->new($self->session,$now)->toDatabase;
my $endTime = WebGUI::DateTime->new($self->session,'2036-01-01 00:00:00')->toDatabase;
$self->{_data}{'name' } = $properties->{name} || $self->{_data}{name} || $self->session->user->username." / ".$self->session->datetime->epochToHuman()." (Autotag)";
$self->{_data}{'workflowId'} = $properties->{workflowId} || $self->{_data}{workflowId} || $self->session->setting->get("defaultVersionTagWorkflow");
$self->{_data}{'groupToUse'} = $properties->{groupToUse} || $self->{_data}{groupToUse} || "12";
#In case of site wide version tag, mark it as Site wide autotag instead
my $isSiteWide = $properties->{isSiteWide} || $self->{_data}{isSiteWide} || 0;
$self->{_data}{'name' } = $properties->{name} || $self->{_data}{name} || $self->session->user->username." / ".$self->session->datetime->epochToHuman().($isSiteWide ? q{ (Site wide autotag)} : q{ (Autotag)});
$self->{_data}{'workflowId'} = $properties->{workflowId} || $self->{_data}{workflowId} || $self->session->setting->get("defaultVersionTagWorkflow");
$self->{_data}{'groupToUse'} = $properties->{groupToUse} || $self->{_data}{groupToUse} || "12";
#This is necessary for upgrade prior to 7.5.11 in order to ensure that this field exists.
#The if() blocks should be removd once the next branch point is reached.
my $assetVersionTagDesc = $self->session->db->buildHashRef('describe assetVersionTag');
@ -572,15 +673,22 @@ sub set {
$self->{_data}{'startTime' } = $properties->{startTime} || $self->{_data}{startTime} || $startTime;
$self->{_data}{'endTime' } = $properties->{endTime} || $self->{_data}{endTime} || $endTime;
}
if (exists $properties->{comments}) {
$self->{_data}{comments}=$self->session->datetime->epochToHuman.' - '.$self->session->user->username
."\n"
.$properties->{comments}
."\n\n"
.$self->{_data}{comments};
}
$self->session->db->setRow("assetVersionTag","tagId",$self->{_data});
}
#New field isSiteWide is added. Check if field exists. This is needed to let upgrades work
if (grep { $_ =~ /^isSiteWide/ } keys %{$assetVersionTagDesc}) {
$self->{_data}{'isSiteWide'} = $isSiteWide;
}
if (exists $properties->{comments}) {
$self->{_data}{comments}=$self->session->datetime->epochToHuman.' - '.$self->session->user->username
."\n"
.$properties->{comments}
."\n\n"
.$self->{_data}{comments};
}
$self->session->db->setRow("assetVersionTag","tagId",$self->{_data});
} #set
#-------------------------------------------------------------------

23
lib/WebGUI/i18n/English/WebGUI.pm Normal file → Executable file
View file

@ -4147,6 +4147,29 @@ LongTruncOk=1</p>
context => q{Label for the user profile field used by the UsersOnline macro},
},
#Support for versionTagMode.
'version tag mode' => {
message => q{Version tag mode},
},
'version tag mode help' => {
message => q{Version tag mode help...TODO},
},
'versionTagMode multiPerUser' => {
message => q{Multi version tags per user},
},
'versionTagMode singlePerUser' => {
message => q{Single version tag per user},
},
'versionTagMode siteWide' => {
message => q{One site wide version tag},
},
'versionTagMode autoCommit' => {
message => q{Commit automatically},
},
'versionTagMode inherited' => {
message => q{Inherit from site settings},
},
};
1;

150
t/VersionTag.t Normal file → Executable file
View file

@ -14,7 +14,7 @@ use lib "$FindBin::Bin/lib";
use WebGUI::Test;
use WebGUI::Session;
use WebGUI::VersionTag;
use Test::More tests => 34; # increment this value for each test you create
use Test::More tests => 60; # increment this value for each test you create
my $session = WebGUI::Test->session;
@ -30,6 +30,65 @@ sub ok_open {
sub getWorking { WebGUI::VersionTag->getWorking($session, @_) }
sub getWorkingId { my $w = getWorking(@_); defined($w)? $w->getId : undef }
# versionTagMode support. Test that setting version tag mode works. Also, make
# sure that the versionTagMode is in multiPerUser before running the test below.
sub setSiteVersionTagMode {
my ($session, $newMode) = @_;
$session->setting()->set(q{versionTagMode}, $newMode);
return;
} #setSiteVersionTagMode
sub setUserVersionTagMode {
my ($user, $newMode) = @_;
$user->profileField(q{versionTagMode}, $newMode);
return;
} #setUserVersionTagMode
can_ok(
q{WebGUI::VersionTag},
q{getVersionTagMode},
);
my $user = $session->user();
setSiteVersionTagMode($session, q{multiPerUser});
setUserVersionTagMode($user, q{inherited});
is (
WebGUI::VersionTag->getVersionTagMode($session),
q{multiPerUser},
q{versionTagMode: both site and user setting multiPerUser},
);
setUserVersionTagMode($user, q{singlePerUser});
is (
WebGUI::VersionTag->getVersionTagMode($session),
q{singlePerUser},
q{versionTagMode: user setting singlePerUser overrides site setting},
);
setSiteVersionTagMode($session, q{autoCommit});
is (
WebGUI::VersionTag->getVersionTagMode($session),
q{singlePerUser},
q{versionTagMode: update site setting doesn't update user setting},
);
setUserVersionTagMode($user, q{multiPerUser});
is (
WebGUI::VersionTag->getVersionTagMode($session),
q{multiPerUser},
q{versionTagMode: update user setting to multiPerUser},
);
my $tag = WebGUI::VersionTag->create($session, {});
isa_ok($tag, 'WebGUI::VersionTag', 'empty tag');
ok(defined $tag->getId, 'empty tag has an ID');
@ -105,6 +164,95 @@ $tag3->rollback;
$tag4->rollback;
($asset1, $asset2, $asset3, $tag3, $tag4) = ();
#additional tests for versionTagMode
#
setSiteVersionTagMode($session, q{singlePerUser});
setUserVersionTagMode($user, q{inherited});
ok(!defined getWorking(1), 'versionTagMode singlePerUser: no working tag initially present');
$tag = WebGUI::VersionTag->create($session, {});
isa_ok($tag, 'WebGUI::VersionTag', 'versionTagMode singlePerUser: empty tag');
ok(defined $tag->getId, 'versionTagMode singlePerUser: empty tag has an ID');
ok(!$tag->get(q{isSiteWide}), 'versionTagMode singlePerUser: empty is not site wide');
my $userTagId = $tag->getId();
my $userTag; # user tag in singlePerUser;
my $siteWideTagId;
my $siteWideTag;
$tag->clearWorking();
ok(defined ($userTag = getWorking(1)), 'versionTagMode singlePerUser: reclaim version tag after clearWorking');
is ($userTag->getId(), $userTagId, q{versionTagMode singlePerUser: reclaimed version tag has same id});
#switch to sitewide mode
$userTag->clearWorking();
setSiteVersionTagMode($session, q{siteWide});
ok(!defined ($siteWideTag = getWorking(1)), 'versionTagMode siteWide: no working tag initially present');
$siteWideTag = getWorking(); #force create
isa_ok($siteWideTag, 'WebGUI::VersionTag', 'versionTagMode siteWide: empty tag');
ok($siteWideTag->get(q{isSiteWide}), 'versionTagMode ssiteWide: empty is site wide');
ok(defined ($siteWideTagId = $siteWideTag->getId()), 'versionTagMode siteWide: empty tag has an ID');
ok($siteWideTag->getId() ne $userTagId, 'versionTagMode siteWide: siteWide tag has different version tag id');
$siteWideTag->clearWorking();
my $asset4 = WebGUI::Asset->getRoot($session)->addChild({ className => 'WebGUI::Asset::Snippet' });
ok(defined ($siteWideTag = getWorking(1)), 'versionTagMode siteWide: reclaim version tag after clearWorking and addding new asset');
is($siteWideTag->getId(), $siteWideTagId, 'versionTagMode siteWide: reclaim site wide version tag has correct id');
## Through in a new session as different user
my $admin_session = WebGUI::Session->open($WebGUI::Test::WEBGUI_ROOT, $WebGUI::Test::CONFIG_FILE);
$admin_session->user({'userId' => 3});
setUserVersionTagMode($admin_session->user(), q{singlePerUser});
my $adminUserTag = WebGUI::VersionTag->getWorking($admin_session, 0);
isa_ok($adminUserTag, 'WebGUI::VersionTag', 'versionTagMode siteWide + admin singlePerUser: empty tag');
ok(defined $adminUserTag->getId(), 'versionTagMode siteWide + admin singlePerUser: empty tag has an ID');
ok(!$adminUserTag->get(q{isSiteWide}), 'versionTagMode siteWide + admin singlePerUser: empty is not site wide');
ok($adminUserTag->getId() ne $userTagId, 'versionTagMode siteWide + admin singlePerUser: empty has different ID');
ok($adminUserTag->getId() ne $siteWideTagId, 'versionTagMode siteWide + admin singlePerUser: empty has different ID than site wide');
# Now switch to site wide
$adminUserTag->clearWorking();
setUserVersionTagMode($admin_session->user(), q{inherited});
my $adminSiteWideTag = WebGUI::VersionTag->getWorking($admin_session, 0);
isa_ok($adminSiteWideTag, 'WebGUI::VersionTag', 'versionTagMode siteWide + admin inherited: reclaimed empty tag');
ok($adminSiteWideTag->get(q{isSiteWide}), 'versionTagMode siteWide + admin inherited: empty is site wide');
ok($adminSiteWideTag->getId() eq $siteWideTagId, 'versionTagMode siteWide + admin inherited: empty has same ID as site wide');
$admin_session->var()->end();
$admin_session->close();
$userTag->rollback();
$siteWideTag->rollback();
$adminUserTag->rollback();
#reset (just in case other tests depends on this setting)
setSiteVersionTagMode($session, q{multiPerUser});
setUserVersionTagMode($user, q{inherited});
# Local variables:
# mode: cperl
# End: