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

lib/WebGUI/Auth.pm

@@ -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;
 }
 

lib/WebGUI/Operation/Settings.pm

@@ -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",
+        # Support for versionTagMode. We'll have:
-		fieldType=>"yesNo",
+        # - multi version tag per user
-        name=>"autoRequestCommit",
+        # - one version tag per user (SwiftySite mode)
-        label=>$i18n->get("auto request commit"),
+        # - one site wide version tag
-        hoverHelp=>$i18n->get("auto request commit help"),
+        # - auto commit
-        defaultValue=>$setting->get("autoRequestCommit")
+        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",

lib/WebGUI/VersionTag.pm

@@ -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 $class    = shift;
-	my $session = shift;
+    my $session  = shift;
-	my $noCreate = shift;
+    my $noCreate = shift;
-	if ($session->stow->get("versionTag")) {
+
-		return $session->stow->get("versionTag");
+    my $stow = $session->stow();
-	} else {
+    my $mode = $class->getVersionTagMode($session);
-		my $tagId = $session->scratch->get("versionTag");
+    my $tag;
-		if ($tagId) {
+    my $tagId;
-			my $tag = $class->new($session, $tagId);
+
-			$session->stow->set("versionTag",$tag);
+    #First see if there is already a version tag
-			return $tag;
+    $tag = $stow->get(q{versionTag});
-		} elsif ($noCreate) {
+
-			return undef;
+    return $tag if $tag;
-		} else {
+
-			my $tag = $class->create($session);
+    $tagId = $session->scratch()->get(q{versionTag});
-			$tag->setWorking;
+    if ($tagId) {
-			return $tag;	
+        $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 $self = shift;
-	my $properties = 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)";
+    #In case of site wide version tag, mark it as Site wide autotag instead
-	$self->{_data}{'workflowId'} = $properties->{workflowId} || $self->{_data}{workflowId} || $self->session->setting->get("defaultVersionTagWorkflow");
+    my $isSiteWide = $properties->{isSiteWide} || $self->{_data}{isSiteWide} || 0;
-	$self->{_data}{'groupToUse'} = $properties->{groupToUse} || $self->{_data}{groupToUse} || "12";
+
-    
+    $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
+    #New field isSiteWide is added. Check if field exists. This is needed to let upgrades work
-                                ."\n"
+    if (grep { $_ =~ /^isSiteWide/ } keys %{$assetVersionTagDesc}) {
-                                .$properties->{comments}
+
-                                ."\n\n"
+        $self->{_data}{'isSiteWide'} = $isSiteWide;
-				.$self->{_data}{comments};
+    }
-	}
+
-	$self->session->db->setRow("assetVersionTag","tagId",$self->{_data});
+    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
 
 #-------------------------------------------------------------------
 

lib/WebGUI/i18n/English/WebGUI.pm

@@ -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;

t/VersionTag.t

@@ -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: