Easy recreation of "Shared, Desktop Private on 1st use" views

I have some views that uses @UserName in the selection formula. For working that, the view must be "Shared, Desktop Private on 1st use". That is no problem.

But this views are going to be redesigned quiet often.

As this is a bunch of views it is very uncomfortable for the user to delete each of this views to recreate from scratch with design changes.

I try different things to get that done with an agent but no one is fool-proof and give some strange results (sometimes even do not update the design).

Best result so far is to delete the icon from the workspace and open the application again. That works (until now) always. But this is so annoying for end users to reopen the app from the (deep leveled) server folders.

Any other meth开发者_StackOverflow社区od to update the design of "private on 1st use" views ?

As you noticed, private views are a pain to maintain. Why not go a different way to solve your problem?

Create a categorized view, where the first, categorized column contains the field you compare the username in your current solution to. Than embed that view into a form as a "single category embedded view" and use @username as the category.

Presto. Now you have a view that only shows documents for the current user and you can change the design whenever you like.

Mick Moignard has a good article on that topic online: Dynamic view filtering in Notes.

See also the Lotus Domino Designer Help, Topic "To show a single category in embedded views"

I have tried to solve the same problem and ended up doing two things - (1) automatically send the user an email with a link to the database and ask them to remove the database icon so that the private views get deleted and (2) alert the user when the design of a private view has changed.

The first part was fairly simple - I wrote a LotusScript function that would send the current user an email message containing a link to the current database (the one that contains the private views), along with some meaningful text and database information. All the user had to do then was exit the database, remove the database icon, open the email they just received and open the database again using the link. No need to navigate the server folders or wonder which server to go to. This can be used on its own, e.g. in a button, but I ended up combining it with something a little more tricky.

The second part was devising a way to alert the user that the design of the view they are opening is outdated. The tricky part was detecting that the design of the view has changed. What made this possible was what actually caused the problem in the first place - the fact that Notes caches the private view. When caching the private view, Notes also caches constants that the script in the view events refer to, that are part of LotusScript libraries the view uses.

Here's a description of the design I used:

• Let the view use shared script library, PrivateViewsCode.
• In PrivateViewsCode's (Declarations) declare Const DESIGN_VERSION = "1.0".
• In PrivateViewsCode declare function myQueryopen. One of the parameters myQueryopen receives is string designVersion.
• In the private view's Queryopen event call myQueryopen, passing DESIGN_VERSION to designVersion. Since this code is in the view that is cached, DESIGN_VERSION will contain the constant value as it were in the moment the view design was cached (when the user first opened it), in this case - "1.0".

• In myQueryopen compare designVersion to DESIGN_VERSION.

  Dim designChanged As Integer  
  designChanged = (designVersion <> DESIGN_VERSION)  
  

  Since myQueryopen is part of PrivateViewsCode script library, here you actually compare the DESIGN_VERSION (as cached in the private view and then passed to myQueryopen) to DESIGN_VERSION from PrivateViewsCode, which is always current.

• The only thing left is to be sure to recompile the views (Tools\Recompile all LotusScript) after changing DESIGN_VERSION.

I hope this explains the design, here is how it works:

• After making changes to private views design you change the version:

  DESIGN_VERSION = "1.1"  
  

• Recompile all LotusScript.
• Refresh the database design.
• Users open any private view that uses this functionality.
• They get a message saying they will receive link to the database and that they have to remove the icon from the workspace and open it again using the provided link.
• The user closes the database and removes the icon - private views are deleted.
• The user opens the database link in the email, the next time they open one of the private views, the new design is cached along with the new value of DESIGN_VERSION (here, "1.1").
• The comparison (designVersion <> DESIGN_VERSION) now yields false. Everything is back to normal until the next update.

Ken's way of handling this has the major advantage of not involving the users at all. This wasn't an option for me because of the frequency with which I made changes to the views (the application was just deployed and I had many requests for changes to the views) as well as the big number of private views in the application.

(Edit)
I assumed you had a specific reason to use private views, but I used the "Show Single Category" in an embedded view (just as leyrer suggests) ever since it became available and was quite happy with it. If you see any limitations to using the "Show Single Category" option, I'll try to help you with that.

I found a way that moves the pain from the end user to the developer. I designed the navigation to use outlines so I can control where the user goes when they navigate to a view. Notes outline entries can be changed without the user needing to go through the delete-icon-then-reopen-database hassle.

When I need to update the design of the private view, I rename it as well and also update the reference to it in the notes outline entry. At the users desktop, when they next open the database, a new private view will be created for them. Most (or all) of my users never noticed anything, at least they never mentioned it!

The process is fairly easy for the developed but also fairly easy to forget. Also, the user's workspace will end up having a lot of references to old unused private views, which if they are large in size might become a problem down the line. If you change the view twenty times, or change twenty views, for example, it may be time to delete the icon to clear them out. For me the changes were rare enough for this not to matter.

The solution to your dilemma is not too hard to solve, but a little tedious. There is a technote on simply removing private views programmatically. It is a common design issue for developers.

I have had to take the following approach to manage multiple private views which were all going through multiple versions at any one time.

The secret is to do a check on the DatabaseOpen event, as it's a view held on the local client so you need to do this through user's UI activity. As long as your Lotus Notes client fleet is at running version 6.5.x you could try the following. To be concise, I have outlined what you need to do.

1. Name your private view "yourPrivateViewName_1.0|yourPrivateViewName"

   • Note the use of an alias. This is so you can reference the view in an outline or code, no matter how many versions you use.
   • This can also be a multi-valued field if you have more than one private view to manage.

2. Create a database profile document that has a field with the current private view name, eg "youPrivateViewName_1.1"

3. On DatabaseOpen loop through the views, finding the private view(s) then compare the name to the one in the database profile. The naming convention is designed to make it possible to do a version check. If the versions don't match, remove the view. When the user opens that view the next time it should grab the current version you have released.

There are other ways as well, like checking the timestamps on the private view and the template, but it still requires a way to single out the private view. But I found this way easy enough to manage.

Thank you all !

I finally ended up with the following:

Create an Agent running from menus that close the database

Sub Initialize
    Dim s As New NotesSession
    s.SetEnvironmentVar "remove-"+s.CurrentDatabase.ReplicaID,"1"
    Dim ws As New NotesUIWorkspace
    ws.CurrentDatabase.Close
End Sub

In the database close event mail a database link and send keys to remove from workspace

Declare Sub keybd_event Lib "user32.dll" (Byval bVk As Integer, Byval
 bScan As Integer, Byval dwFlags As Integer,Byval dwExtraInfo As Integer)

Sub Queryclose(Source As Notesuidatabase, Continue As Variant)

    Dim s As New NotesSession
    x = s.GetEnvironmentString("remove-"+s.CurrentDatabase.ReplicaID)
    s.SetEnvironmentVar "remove-"+s.CurrentDatabase.ReplicaID,""
    If x="" Then Exit Sub

    Dim ws As New NotesUIWorkspace
    Call ws.AddDatabase( s.CurrentDatabase.Server,s.CurrentDatabase.FilePath)

    Dim m As New NotesDocument(s.CurrentDatabase)

    m.From = s.CurrentDatabase.Title
    m.SendTo = s.CommonUserName
    m.Subject = "Link to open " + s.CurrentDatabase.Title

    Dim rt As New NotesRichTextItem(m,"Body")
    rt.AppendText s.CurrentDatabase.Title
    rt.AppendText " -> "
    rt.AppendDocLink s.CurrentDatabase,"Open Application"

    m.Send False
    Delete m

    keybd_event &h2e,0,0,0 ' Del key down
    keybd_event &h2e,0,2,0 ' Del key up
    keybd_event &h0D,0,0,0 ' Y key down
    keybd_event &h0D,0,2,0 ' Y key up

End Sub

(You all got your upvotes but a i mark as answer for the lowest rep. points user.)