FEED Validator

for Atom and RSS and KML

Congratulations!

This is a valid RSS feed.

Recommendations

This feed is valid, but interoperability with the widest range of feed readers could be improved by implementing the following recommendations.

Your feed appears to be encoded as "ISO-8859-1", but your server is reporting "US-ASCII" [help]
line 41, column 10: category should not be blank (8 occurrences) [help]
```
<category></category>
          ^
```
line 62, column 0: Invalid HTML: malformed start tag, at line 1, column 10998 (3 occurrences) [help]
```
<content:encoded><![CDATA[ <span style=" font-size:10pt;font-family:sans-ser ...
```

line 97, column 8915: content:encoded contains bad characters (83 occurrences) [help]

... 7-15') and Date_origin <@dt('2015-07-14â\x80\x99) and <br /> partno in all ( 3 ...
                                             ^

line 165, column 0: Non-html tag: notes [help]

<content:encoded><![CDATA[ <span style=" font-size:10pt;font-family:sans-ser ...

line 356, column 0: Missing atom:link with rel="self" [help]
```
</channel></rss>
```

Source: http://www.mindoo.com/web/blog.nsf/feed.rss

<?xml version="1.0" encoding="ISO-8859-1"?>
<rss version="2.0"
xmlns:dc="http://purl.org/dc/elements/1.1/"
xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
xmlns:admin="http://webns.net/mvcb/"
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:content="http://purl.org/rss/1.0/modules/content/"
xmlns:wfw="http://wellformedweb.org/CommentAPI/">
<channel>
<title>Mindoo Blog</title>
<description>Cutting edge technologies - About Java, Lotus Notes and iPhone</description>
<link>https://www.mindoo.de/web/blog.nsf/</link>
<language>en-us</language>
<lastBuildDate>Fri, 23 Aug 2024 23:22:29 +0200</lastBuildDate>
<item>
<title>Session recording for Domino JNA Virtual View API available on YouTube</title>
<pubDate>Fri, 23 Aug 2024 23:22:29 +0200</pubDate>
<description>
<![CDATA[
On the 18th of July 2024 I attended the OpenNTF "Develop Variety Hour" and presented the new Domino JNA Virtual View API. The recording for this session is now available here: https://www.youtube.com ...
]]>
</description>
<link>https://www.mindoo.com/web/blog.nsf/dx/23.08.2024232229KLET3L.htm</link>
<category>Domino C API</category>
<dc:creator>Karsten Lehmann</dc:creator>
<comments>https://www.mindoo.com/web/blog.nsf/dx/23.08.2024232229KLET3L.htm?opendocument&comments</comments>
<guid isPermaLink="true">https://www.mindoo.com/web/blog.nsf/dx/23.08.2024232229KLET3L.htm</guid>
<content:encoded><![CDATA[ On the 18th of July 2024 I attended the OpenNTF "Develop Variety Hour" and presented the new Domino JNA Virtual View API. The recording for this session is now available here: <a href="https://www.youtube.com/watch?v=TGsudzbvbmc&t=1417s" target=_blank>https://www.youtube.com/watch?v=TGsudzbvbmc&t=1417s</a> Video description from YouTube: In this webinar Jesse Gallagher is joined by Karsten Lehmann, Paul Withers and Alec Vincent Bardiano to touch on a set of developer-related topics in the HCL Domino world.  Namely, Jesse talks about contributing to open source projects in general, and also highlights some relevant current projects including Domino JNX, Domino Rust Addin and HCL's Open-Source templates, Paul shares more about a project, Bali Unit, that is a port of VoltScript testing that may be used in LotusScript, and Alec presents some nice information about the Domino REST API Node.js and Go SDKs. The slides for Jesse's portion of the webinar may be downloaded <a href="https://www.openntf.org/Public/presentations.nsf/0/EC05AD9CA48DE52D86258B79004CC639/$FILE/2024-07_OpenNTF_Developer_Variety_Hour.pdf" target=_blank>https://www.openntf.org/Public/presentations.nsf/0/EC05AD9CA48DE52D86258B79004CC639/$FILE/2024-07_OpenNTF_Developer_Variety_Hour.pdf</a> ]]></content:encoded>
<wfw:commentRss> https://www.mindoo.com/web/blog.nsf/dxcomments/23.08.2024232229KLET3L.htm</wfw:commentRss>
<wfw:comment> https://www.mindoo.com/web/blog.nsf/dx/23.08.2024232229KLET3L.htm?opendocument&comments</wfw:comment>
</item>
<item>
<title>New Domino JNA version 0.9.53 and source code for our Virtual View API demo app</title>
<pubDate>Sat, 20 Jul 2024 23:04:19 +0200</pubDate>
<description>
<![CDATA[
As announced in the last article Demo application for Domino JNA Views to play with, I just released a new version of Domino JNA, version 0.9.53, with these changes; fixed a VirtualViewNavigator issu ...
]]>
</description>
<link>https://www.mindoo.com/web/blog.nsf/dx/20.07.2024230419KLESQ9.htm</link>
<category></category>
<dc:creator>Karsten Lehmann</dc:creator>
<comments>https://www.mindoo.com/web/blog.nsf/dx/20.07.2024230419KLESQ9.htm?opendocument&comments</comments>
<guid isPermaLink="true">https://www.mindoo.com/web/blog.nsf/dx/20.07.2024230419KLESQ9.htm</guid>
<content:encoded><![CDATA[ As announced in the last article <a href="https://www.mindoo.com/web/blog.nsf/dx/18.07.2024175024KLELL4.htm">Demo application for Domino JNA Views to play with</a>, I just released a new version of Domino JNA, version 0.9.53, with these changes; <ul><li>fixed a VirtualViewNavigator issue where a navigator created via buildFromCategory(...) returns entries out of subtree when using gotoPos() and navigating</li><li>code for VirtualViewNavigator read access check can now be customized by implementing com.mindoo.domino.jna.virtualviews.security.IViewEntryAccessCheck or subclassing com.mindoo.domino.jna.virtualviews.security.ViewEntryAccessCheck when creating the navigator</li><li>new API method com.mindoo.domino.jna.virtualviews.VirtualViewNavigator.entriesForwardFromPosition(String, SelectedOnly)</li></ul> These were findings and feedback I got from creating/showing my Virtual View API demo application at the recent <a href="https://www.openntf.org/main.nsf/blog.xsp?permaLink=JGAR-D78NL4" target=_blank>OpenNTF developer webinar</a>. <img alt="Image:New Domino JNA version 0.9.53 and source code for our Virtual View API demo app" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/20.07.2024230419KLESQ9.htm/content/M2?OpenElement" /> The source code for the demo application that can be tested here <a href=https://www.mindoo.de/test/jnavirtualviews.nsf/sunburst.xsp target=_blank>https://www.mindoo.de/test/jnavirtualviews.nsf/sunburst.xsp</a> is now also available on GitHub: <a href="https://github.com/klehmann/JNA-Virtual-Views-Demo" target=_blank>https://github.com/klehmann/JNA-Virtual-Views-Demo</a> ]]></content:encoded>
<wfw:commentRss> https://www.mindoo.com/web/blog.nsf/dxcomments/20.07.2024230419KLESQ9.htm</wfw:commentRss>
<wfw:comment> https://www.mindoo.com/web/blog.nsf/dx/20.07.2024230419KLESQ9.htm?opendocument&comments</wfw:comment>
</item>
<item>
<title>Demo application for Domino JNA Views to play with</title>
<pubDate>Thu, 18 Jul 2024 17:50:24 +0200</pubDate>
<description>
<![CDATA[
Today I attended the "Developer Variety Hour" webinar of OpenNTF and did a demo of the new Virtual View API of Domino JNA. I built a small web application that combines a Sunburst diagram (taken from ...
]]>
</description>
<link>https://www.mindoo.com/web/blog.nsf/dx/18.07.2024175024KLELL4.htm</link>
<category>Domino C API</category>
<dc:creator>Karsten Lehmann</dc:creator>
<comments>https://www.mindoo.com/web/blog.nsf/dx/18.07.2024175024KLELL4.htm?opendocument&comments</comments>
<guid isPermaLink="true">https://www.mindoo.com/web/blog.nsf/dx/18.07.2024175024KLELL4.htm</guid>
<content:encoded><![CDATA[ Today I attended the "Developer Variety Hour" webinar of OpenNTF and did a demo of the new <a href="https://www.mindoo.com/web/blog.nsf/dx/13.07.2024001044KLETZR.htm">Virtual View API of Domino JNA</a>. I built a small web application that combines a Sunburst diagram (taken from the <a href=https://d3js.org/ target=_blank>D3 website</a>, enhanced by a training session with Anthropics Claude AI chat :-) ) with a categorized view, built on top of a Bootstrap 5 table. The application looks like this: <img alt="Image:Demo application for Domino JNA Views to play with" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/18.07.2024175024KLELL4.htm/content/M2?OpenElement" /> and it's available for you to play with here: <a href=https://www.mindoo.de/test/jnavirtualviews.nsf/sunburst.xsp target=_blank>https://www.mindoo.de/test/jnavirtualviews.nsf/sunburst.xsp</a> Both components fetch their data from an XAgent style XPage where a Virtual View is used to read document information from two fakenames databases: public Optional< VirtualView > getViewById(String id) {         VirtualView view = null;                         if ("fakenames_bycontinent_categorized".equals(id)) {                                         view = VirtualViewFactory.INSTANCE.createViewOnce(id,                                 17, // view version number                                 10, TimeUnit.MINUTES, // keep in memory for 10 minutes                                 (viewId) -> {                         return VirtualViewFactory.createView(                                                                                         // use a Java function to compute the "Continent" category:                                                                                         new VirtualViewColumn("Continent", "$1", Category.YES, Hidden.NO, ColumnSort.ASCENDING, Total.NONE,                                                         new VirtualViewColumnValueFunction< String >(1) {                                                                                                         @Override                                                 public String getValue(String origin, String itemName,                                                         INoteSummary columnValues) {                                                         String companyName = columnValues.getAsString("CompanyName", "");                                                                                                                         Map<String,String> lookupMap = getCompanyContinentMap();                                                         return lookupMap.getOrDefault(companyName, "Unknown");                                                 }                                                                                                 }),                                         // use formula language for the remaining columns:                                                                                         new VirtualViewColumn("Company Name", "$2", Category.YES, Hidden.NO,                                                 ColumnSort.ASCENDING, Total.NONE,                                                 "@Left(CompanyName;1) + \"\\\\\" + CompanyName"),                                         new VirtualViewColumn("Lastname", "Lastname", Category.NO, Hidden.NO,                                                 ColumnSort.ASCENDING, Total.NONE,                                                 "Lastname"),                                         new VirtualViewColumn("Firstname", "Firstname", Category.NO, Hidden.NO,                                                 ColumnSort.ASCENDING, Total.NONE,                                                 "Firstname"),                                         new VirtualViewColumn("CompanyName", "CompanyName", Category.NO,                                                 Hidden.YES, ColumnSort.NONE, Total.NONE,                                                 "CompanyName")                                         )                                         // load data from two fakenames databases                                         .withDbSearch("fakenames1", "", "fakenames.nsf", "Form=\"Person\"")                                         .withDbSearch("fakenames2", "", "fakenames2.nsf", "Form=\"Person\"")                                         .build();                 });         }         return Optional.ofNullable(view); } Initial index generation for about 40.000 fakenames docs takes 5 seconds on our server. The view is set to expire after 10 minutes and will be automatically be rebuilr. The first column value is computed via Java code and looks up the continent for the company name of a fakenames person (let's call it a JOIN operation). Since all data access is done in-memory (no legacy Domino view is required), REST API response times are ultra-fast and take 50ms for each request. Part of those 50ms is opening the two fakenames database and checking if anything relevant has been changed/added/deleted. As presented in the webinar, changing DB documents is immediately reflected in the web app. Building this demo app this week I discovered a few issues in the Virtual View API of Domino JNA 0.9.52 especially when processing NSF changes (the code produced duplicate rows). I will publish a new Domino JNA version this week with fixes. ]]></content:encoded>
<wfw:commentRss> https://www.mindoo.com/web/blog.nsf/dxcomments/18.07.2024175024KLELL4.htm</wfw:commentRss>
<wfw:comment> https://www.mindoo.com/web/blog.nsf/dx/18.07.2024175024KLELL4.htm?opendocument&comments</wfw:comment>
</item>
<item>
<title>Domino JNA Virtual Views: The Next Step in Domino Data Retrieval</title>
<pubDate>Sun, 14 Jul 2024 00:10:00 +0200</pubDate>
<description>
<![CDATA[
In the previous two articles, "The pain of reading data as a Domino developer - and solutions" and "Overview of Domino Data Retrieval: Exploring NSF Search, DQL, Domino Views, and the QueryResultsProc ...
]]>
</description>
<link>https://www.mindoo.com/web/blog.nsf/dx/13.07.2024001044KLETZR.htm</link>
<category>Domino C API</category>
<dc:creator>Karsten Lehmann</dc:creator>
<comments>https://www.mindoo.com/web/blog.nsf/dx/13.07.2024001044KLETZR.htm?opendocument&comments</comments>
<guid isPermaLink="true">https://www.mindoo.com/web/blog.nsf/dx/13.07.2024001044KLETZR.htm</guid>
<content:encoded><![CDATA[ In the previous two articles, "<a href="https://www.mindoo.com/web/blog.nsf/dx/19.06.2024110207KLECLW.htm">The pain of reading data as a Domino developer - and solutions</a>" and "<a href="https://www.mindoo.com/web/blog.nsf/dx/13.07.2024000446KLETW2.htm">Overview of Domino Data Retrieval: Exploring NSF Search, DQL, Domino Views, and the QueryResultsProcessor</a>", we explored the challenges and solutions for efficiently accessing and processing data in Domino. Now, let's delve into the next evolution in Domino data handling. Version 0.9.49 of our <a href="https://github.com/klehmann/domino-jna" target=_blank>Domino JNA open-source project</a> introduced a new API called "Virtual Views", built with all the NIF, formula search, DQL, and QueryResultsProcessor history and limitations in mind. In short, you define the view structure as a VirtualView object in your Java code (columns with sorting, categorization, total, and average values) and then add one or more data providers that incrementally push data into the view (or remove it). This article will guide you through the innovative features and capabilities of the Virtual View API, demonstrating how it simplifies and enhances data retrieval and manipulation in Domino. Now, let's take a closer look at how you can leverage the Virtual View API to define and manage views dynamically in your Java code. To illustrate, consider the following code: <code><tt>Map<String,String> someExternalData = new HashMap<>();</tt> <tt> someExternalData.put("Revoco", "Revoco Street 5, Los Angeles");</tt> <tt> someExternalData.put("Omnis", "Omnis Boulevard 12, New York");</tt> <tt> // by using "createViewOnce", we mark the view to be stored in memory,</tt> <tt> // as a version "1" and to auto discard it</tt> <tt> // after 5 minute of inactivity (just for testing, in production you'd use a higher value)</tt> <tt> // changing the version number to "2" would force a new view to be created</tt> <tt> VirtualView view = VirtualViewFactory.INSTANCE.createViewOnce("fakenames_namelengths",</tt> <tt>        1, </tt><tt>// version "1"</tt> <tt>        5, TimeUnit.MINUTES, </tt><tt>// auto discard after 5 minute of inactivity</tt> <tt>                             // (calling createViewOnce resets the counting)</tt> <tt>        (id) -> {</tt> <tt>    return VirtualViewFactory.createView(</tt> <tt>            new VirtualViewColumn("Lastname", "Lastname",</tt> <tt>                    Category.YES, Hidden.NO, ColumnSort.ASCENDING, Total.NONE,</tt> <tt>                    "Lastname"),</tt> <tt>            new VirtualViewColumn("Firstname", "Firstname",</tt> <tt>                    Category.NO, Hidden.NO, ColumnSort.ASCENDING, Total.NONE,</tt> <tt>                    "Firstname"),</tt> <tt>            new VirtualViewColumn("Total Name Length", "TotalNameLength",</tt> <tt>                    Category.NO, Hidden.NO, ColumnSort.NONE, Total.SUM,</tt> <tt>                    new VirtualViewColumnValueFunction< Integer >(1) {</tt> <tt>                                           // this 1 is a version number for</tt> <tt>                                           // the column function, might become</tt> <tt>                                           // relevant later when we store the index to disk</tt> <tt>                @Override</tt> <tt>                public Integer getValue(String origin, String itemName,</tt> <tt>                        INoteSummary columnValues) {</tt> <tt>                    return columnValues.getAsString("Firstname", "").length() + 1 +</tt> <tt>                            columnValues.getAsString("Lastname", "").length();</tt> <tt>                }</tt> <tt>            }),</tt> <tt>            new VirtualViewColumn("Average Name Length", "AverageNameLength",</tt> <tt>                    Category.NO, Hidden.NO, ColumnSort.NONE, Total.AVERAGE,</tt> <tt>                    new VirtualViewColumnValueFunction< Integer >(1) {</tt> <tt>                @Override</tt> <tt>                public Integer getValue(String origin, String itemName,</tt> <tt>                        INoteSummary columnValues) {</tt> <tt>                    return columnValues.getAsString("Firstname", "").length() + 1 +</tt> <tt>                            columnValues.getAsString("Lastname", "").length();</tt> <tt>                }</tt> <tt>            }),</tt> <tt>                        new VirtualViewColumn("Company Address", "CompanyAddress",</tt> <tt>                    Category.NO, Hidden.NO, ColumnSort.NONE, Total.NONE,</tt> <tt>                    new VirtualViewColumnValueFunction< String >(1) {</tt> <tt>                        @Override</tt> <tt>                        public String getValue(String origin, String itemName,</tt> <tt>                                INoteSummary columnValues) {</tt> <tt>                            </tt><tt>// poor man's JOIN :-)</tt> <tt>                            // we fetch the company address from a map</tt> <tt>                            // using the company name as key</tt> <tt>                                                        String companyName = columnValues.getAsString("CompanyName", "");</tt> <tt>                            return someExternalData.getOrDefault(companyName, "");</tt> <tt>                        }</tt> <tt>                    }),</tt> <tt>            new VirtualViewColumn("Last Update", "LastMod",</tt> <tt>                    Category.NO, Hidden.NO, ColumnSort.NONE, Total.NONE,</tt> <tt>                    "LastMod"),</tt> <tt>            </tt><tt>// required to have the CompanyName value available in the summary</tt> <tt>            // buffer so that the Java column function can use it</tt> <tt>            new VirtualViewColumn("Company Name", "CompanyName",</tt> <tt>                    Category.NO, Hidden.YES, ColumnSort.NONE, Total.NONE,</tt> <tt>                    "CompanyName")</tt> <tt>            )</tt> <tt>            </tt><tt>// add one or more data providers with an origin id (here "myfakenames1")</tt> <tt>            .withDbSearch("myfakenames1",</tt> <tt>                    "Server1/Mindoo", "fakenames.nsf",</tt> <tt>                    "Form=\"Person\"")</tt><span style=" font-
size:12pt"> <tt>            </tt><tt>// let's move the categories above the docs like in Windows Explorer</tt> <tt>            .withCategorizationStyle(CategorizationStyle.CATEGORY_THEN_DOCUMENT)</tt> <tt>            .build();</tt> <tt> });</code></tt> In this example, column values are computed via formula and Java code, and a JOIN operation with an external Java Map is performed. More examples can be found here: <a href="https://github.com/klehmann/domino-jna/blob/develop/domino-jna/src/test/java/com/mindoo/domino/jna/test/TestVirtualView.java">https://github.com/klehmann/domino-jna/blob/develop/domino-jna/src/test/java/com/mindoo/domino/jna/test/TestVirtualView.java</a> The data provider implements a simple Java interface, making it easy to add non-Domino data to the view. For Domino, we built several standard implementations that can be mixed and matched for one or multiple databases: <ul><li>datasource 1: run NSF search with a formula (incrementally), can search data and design documents, optional post processing with FT search</li><li>datasource 2: profile documents filtered with a formula</li><li>datasource 3: read note ids from a folder (incrementally),  ideal for displaying folder content in different ways</li><li>datasource 4: compute column values from any list of note IDs (e.g. a DQL result)</li></ul> The VirtualView class manages the categorization tree and document sort order, aggregating computation results on category levels up to an imaginary root element. Readers lists Readers lists are a first-class citizen in the Virtual View API. For documents, we store the individual readers within the view index entry, along with the origin database information. When traversing the view, we compare the readers list with the usernames list of the current user in that specific database. This also works with ACL roles which are defined per database. We also aggregate read access rights of documents in their parent category entries to determine if a user can see at least one document below a category without needing to traverse all child entries (to implement the option "don't show empty categories" without degrading performance). These aggregated readers stats can be read in code, offering insights into the distribution of read access rights across multiple databases. Virtual Views do not need to be created on a per-user basis. The VirtualView object contains all data the server is allowed to see. To traverse the virtual view, we built our own VirtualViewNavigator, instantiated for a specific user and for the whole view or a single category: <tt> <code>VirtualViewNavigator nav = view</tt> <tt>    .createViewNav()</tt> <tt>    .withCategories()</tt> <tt>    .withDocuments()</tt> <tt>    .withEffectiveUserName("CN=Karsten Lehmann/O=Mindoo")</tt> <tt>    .build();</tt> <tt> //  other methods to build the navigator:</tt> <tt> //  .buildFromCategory("Abbott");</tt> <tt> //  .buildFromDescendants(otherViewEntryInTheView);</tt> <tt> nav.expandAll().collapse("1.1");</tt> <tt> if (nav.gotoFirst()) {</tt> <tt>    do {</tt> <tt>       VirtualViewEntryData currentEntry = nav.getCurrentEntry();</tt> <tt>       String firstName = currentEntry.getAsString("firstname", "");</tt> <tt>       String lastName = currentEntry.getAsString("lastname", "");</tt> <tt>    }</tt> <tt>    while (nav.gotoNext());</tt> <tt> }</code></tt> gotoPrev() and gotoNext() manage the expanded/collapsed entries. If you prefer a non-goto syntax, methods like entriesForward(), entriesBackward() and others return Java Streams: <tt> <code>Stream<VirtualViewEntryData> stream = nav</tt> <tt>        .entriesForward()</tt> <tt>        .skip(3000)</tt> <tt>        .limit(200);</tt> <tt> stream</tt> <tt> .forEach(((entry) -> {</tt> <tt>    String firstName = entry.getAsString("firstname","");</tt> <tt>    String lastName = entry.getAsString("firstname","");</tt> <tt> }));</code></tt> The view index is currently stored in memory. We may add a feature to save indexes to disk for quick reloading after an HTTP task restart. Conclusion Here is the full feature list for the Virtual View API in its first version: <ul><li>Multi-DB views</li><li>Works locally, client-server and server-server</li><li>View structure similar to Domino (multi-level categorization, sorted columns)</li><li>Support for sums/average values</li><li>Compute column values via formula or Java code</li><li>Option to place categories above or below documents in categorized views</li><li>Incremental view updates (no rebuild required)</li><li>Full control over when the view is updated, with optional read locks for exclusive access</li><li>Server-populated views, shared across users</li><li>User-specific view entry visibility checks (DB ACL level and usernames list for each DB compared with computed document readers list)</li><li>Aggregated readers stats for categories to quickly skip empty categories for users</li><li>Collected readers stats for analysis purposes</li><li>Several data providers combined to produce view data</li><li>Standard Domino data providers for data/profile/design docs</li><li>Custom non-Domino data support</li><li>VirtualViewNavigator for reading view entries visible to a user, with support for expanded/selected entries, upwards/downwards paging, keyword, and range lookups</li><li>Fast performance (e.g., processes 40,000 fake name docs and builds the view in 2-3 seconds)</li><li>VirtualView currently stored in Java heap (each VirtualViewEntry with a ConcurrentSkipListMap for sorted children), with potential future support for disk serialization</li><li>Not Domino-specific; works for other kinds of data</li></ul> I hope you enjoy this new feature, try it out, and provide feedback! ]]></content:encoded>
<wfw:commentRss> https://www.mindoo.com/web/blog.nsf/dxcomments/13.07.2024001044KLETZR.htm</wfw:commentRss>
<wfw:comment> https://www.mindoo.com/web/blog.nsf/dx/13.07.2024001044KLETZR.htm?opendocument&comments</wfw:comment>
</item>
<item>
<title>Overview of Domino Data Retrieval: Exploring NSF search, DQL, Domino Views and the QueryResultsProcessor</title>
<pubDate>Sat, 13 Jul 2024 23:29:18 +0200</pubDate>
<description>
<![CDATA[
As you read in the previous article "The pain of reading data as a Domino developer - and solutions", looking up data on Domino is not as easy as it seems - especially compared to other platforms like ...
]]>
</description>
<link>https://www.mindoo.com/web/blog.nsf/dx/13.07.2024000446KLETW2.htm</link>
<category>Domino C API</category>
<dc:creator>Karsten Lehmann</dc:creator>
<comments>https://www.mindoo.com/web/blog.nsf/dx/13.07.2024000446KLETW2.htm?opendocument&comments</comments>
<guid isPermaLink="true">https://www.mindoo.com/web/blog.nsf/dx/13.07.2024000446KLETW2.htm</guid>
<content:encoded><![CDATA[ As you read in the previous article "<a href="https://www.mindoo.com/web/blog.nsf/dx/19.06.2024110207KLECLW.htm">The pain of reading data as a Domino developer - and solutions</a>", looking up data on Domino is not as easy as it seems - especially compared to other platforms like SQL. Let's explore the available options. NSF search with formula For many years, formula language was the only universal search language on the platform. However, searching the database took time (method <code>lotus.domino.Database.search(String formula, DateTime dt, int max)</code>) since each document had to be scanned and processed by the formula. The result, a DocumentCollection, is said to have "no particular order," but this isn't entirely accurate. The underlying C data structure of the returned DocumentCollection is an IDTable containing note IDs. To store it efficiently, early Domino core developers decided to sort the note IDs in ascending order. For more on the storage format of IDTables, refer to this interesting knowledge base article: <a href="https://support.hcltechsw.com/csm?id=kb_article&sysparm_article=KB0026700">https://support.hcltechsw.com/csm?id=kb_article&sysparm_article=KB0026700</a> In data processing, the order in which documents are returned by the search call (NSFSearch in the C API) does not matter. You search the entire database and process it (one by one or quickly with one of the stamp methods). To improve performance, the NSFSearch call returns a TIMEDATE value that you can use for subsequent calls to fetch only documents created, changed, or deleted since the given time and whether they do or no longer match the selection formula. Normal NSFSearch calls return the whole summary buffer for each matching document, which can contain a lot of irrelevant information. However, by using a special undocumented format for the compiled search formula (with merged column formulas), some undocumented flags, an undocumented item name ("$C1$"), and an undocumented NSFSearchExtended3 call, things get more interesting. With this method, the search operation only copies the summary buffer data you are interested in, speeding up the search. The item "$C1$" contains the document's readers list, showing who can view a document. If readers are present, it also includes the document's authors. This means there's no need to manually extract this data in your own code; the NSF search operation handles it. Our open-source project, <a href="https://github.com/klehmann/domino-jna" target=_blank>Domino JNA</a>, utilizes this powerful search method in the <a href="https://github.com/klehmann/domino-jna/blob/master/domino-jna/src/main/java/com/mindoo/domino/jna/NotesSearch.java#L372" target=_blank>com.mindoo.domino.jna.NotesSearch</a> class, which is an excellent tool for syncing Domino data with external systems or building custom indexes. These undocumented flags, item and calls are the magic behind Domino views: Domino views End users typically want tabular data sorted by one or more columns, not data sorted by note ID. Domino views are designed for this purpose. They consist of a search formula to select relevant data and column information to visualize the data in a specific order. <img alt="Image:Overview of Domino Data Retrieval: Exploring NSF search, DQL, Domino Views and the QueryResultsProcessor" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/13.07.2024000446KLETW2.htm/content/M2?OpenElement" /> Domino views provide multi-level categories for drilling down into data, which can be expanded/collapsed, and where sums and averages are aggregated (e.g., costs per team, costs per department, costs for a whole company). The view index represents a persistent and always up-to-date formula search result of one NSF database. Only one instance of a specific view index exists on the server. Since view entries contain readers information, the Notes Indexing Facility (NIF) skips rows that a user is not allowed to see by comparing their personal user names list with the allowed readers of a document. String comparison takes time, so if you have a database with 1 million documents and you can only see 10, traversing a view is not fast because 999,990 rows have to be skipped. Domino 14 includes optimizations for these edge cases, such as maintaining an IDTable per user with document note IDs they are allowed to see. This allows the NIF code to skip string comparison and just check if the IDTable contains the note ID. However, these optimizations are not enabled by default for all users. Domino view columns can display document item content, values computed via formula language (e.g., Lastname + ", " + Firstname), or special values like child and descendant counts read from the view index itself. For more details on NIF, check out John Curtis's blog post: <a href="https://jdcurtis.blog/2019/12/16/tdr-notes-indexing-facility">https://jdcurtis.blog/2019/12/16/tdr-notes-indexing-facility</a> Folders Folders work like Domino views, but their content (note IDs) is not retrieved via formula search. Instead, it is added manually by the end user or the application developer. The main use case of a folder is to pick and bookmark documents for future analysis or processing. Domino Query Language Introduced in Domino 10, the Domino Query Language (DQL) provides a concise syntax for finding documents based on a wide variety of terms. It leverages existing design elements without requiring detailed code to access them. Like formula language, DQL can filter documents from a single NSF and return an "unsorted" IDTable. Here is an example of DQL: <code>Order_origin in ('Detroit', 'Albuquerque', 'San Diego') and Date_origin >= @dt('2014-07-15') and Date_origin <@dt('2015-07-14â\x80\x99) and partno in all ( 389, 27883, 388388, 587992 ) and not in ('Special Processing', 'Special2' , 'Soon to be specialâ\x80\x99) and not sales_person in ('Christen Summer', 'Isaac Hart')</code> DQL provides a more efficient way to perform searches compared to formula language. A query planner analyzes a DQL statement and finds the best strategy to quickly reduce the number of relevant documents, such as by doing view lookups or FT searches. A DQL search always returns the complete search result and does not support incremental searching. You can specify views, folders, or document collections to limit the results: <code>in ('TrudisDocs', â\x80\x98Ordersâ\x80\x99, â\x80\x99Special orders folder 1â\x80\x99, â\x80\x98Old_orders 2â\x80\x99)</code> For more DQL examples, visit: <a href=https://help.hcltechsw.com/dom_designer/14.0.0/basic/dql_simple_examples.html>https://help.hcltechsw.com/dom_designer/14.0.0/basic/dql_simple_examples.html</a> As of Domino 14, a DQL search only covers data documents, not design documents. For more details on DQL, see this Admincamp presentation from HCL: <a href="https://admincamp.de/konferenz/ent2019.nsf/bc36cf8d512621e0c1256f870073e627/6c2e835120d74a18c1258327003f8d83/$FILE/T3S4-Demo%20and%20Deep%20Dive%20-%20Domino%20General%20Query%20Facility%20.pdf">https://admincamp.de/konferenz/ent2019.nsf/bc36cf8d512621e0c1256f870073e627/6c2e835120d74a18c1258327003f8d83/$FILE/T3S4-Demo%20and%20Deep%20Dive%20-%20Domino%20General%20Query%20Facility%20.pdf</a> QueryResultsProcessor Introduced in Domino 12, the QueryResultsProcessor processes a list of documents, reads selected values from the documents' summary buffer, and creates tabular data with sorted, categorized, or unsorted columns. The processing result can be returned in JSON format for web applications or materialized as a Domino view in any NSF as a QRP view. Unlike standard Domino views, data from multiple NSFs can be combined in a single QueryResultsProcessor call. For JSON output, there is no paging support (skip/limit), and the result is recomputed on every call. The QRP view is created once and does not update its content, making it suitable for producing snapshots of Domino data at a point in time. Since you can use the normal View APIs (e.g., the ViewNavigator), returning paged data is not difficult. However, the QRP view does not store any readers lists on the row level. The view contains the data that the user creating it was allowed to see. You can only restrict access on the view level, e.g., to hide financial data from normal employees. The primary purpose of QRP views is to produce a snapshot of Domino data at a point in time. They are more of a reporting tool than a good option for real-time queries, because you would need to build one QRP view for each user/user group and discard it as soon as the underlying data has changed, since there is no in-place index update. John Curtis has documented the QueryResultsProcessor in a series of blog articles: <a href="https://jdcurtis.blog/2021/11/29/the-query-results-processor-part-one/">https://jdcurtis.blog/2021/11/29/the-query-results-processor-part-one/</a> <a href="https://jdcurtis.blog/2021/11/30/the-query-results-processor-part-two/">https://jdcurtis.blog/2021/11/30/the-query-results-processor-part-two/</a> <a href="https://jdcurtis.blog/2021/12/02/the-queryresultsprocessor-part-three/">https://jdcurtis.blog/2021/12/02/the-queryresultsprocessor-part-three/</a> Curtis mentioned plans for the future of the QueryResultsProcessor, including refreshable QRP views, joins/lookups across QRP input collections, and incorporating external data into QRP views. However, he retired at the end of 2022, and the QueryResultsProcessor API has since lost momentum. What is missing? As described above, using NSFSearch, it is not difficult to mirror Domino data in real-time in other databases with more capable query languages like SQL, GraphQL, or Cypher (for the Graph DB fans). You can let Domino do all the work, including computing formula values and readers lists. In the past, we built web applications for customers where we pulled the content of 30 NSFs (one for each department) into the JVM heap (max heap set to 30 GB) on HTTP task startup. We used CQEngine (<a href=https://github.com/npgall/cqengine>https://github.com/npgall/cqengine</a>) to build indexes for the data, resulting in extremely fast REST APIs with dynamic filter and sorting options. However, these are custom solutions for each use case. Instead, there should be a standard way that fits many use cases and feels "Domino-like." Let's take the QueryResultsProcessor concept to another level! Let's reinvent the wheel one more time! :-) In the <a href="https://www.mindoo.com/web/blog.nsf/dx/13.07.2024001044KLETZR.htm">next article</a>, I will introduce Domino JNA's new Virtual View API. Stay tuned! ]]></content:encoded>
<wfw:commentRss> https://www.mindoo.com/web/blog.nsf/dxcomments/13.07.2024000446KLETW2.htm</wfw:commentRss>
<wfw:comment> https://www.mindoo.com/web/blog.nsf/dx/13.07.2024000446KLETW2.htm?opendocument&comments</wfw:comment>
</item>
<item>
<title>The pain of reading data as a Domino developer - and solutions</title>
<pubDate>Wed, 19 Jun 2024 11:02:08 +0200</pubDate>
<description>
<![CDATA[
On my endless path of reinventing the wheel regarding Domino APIs, my latest adventure has once again led me to find efficient and powerful ways to query Domino data. For many years, this topic has b ...
]]>
</description>
<link>https://www.mindoo.com/web/blog.nsf/dx/19.06.2024110207KLECLW.htm</link>
<category>Domino C API</category>
<dc:creator>Karsten Lehmann</dc:creator>
<comments>https://www.mindoo.com/web/blog.nsf/dx/19.06.2024110207KLECLW.htm?opendocument&comments</comments>
<guid isPermaLink="true">https://www.mindoo.com/web/blog.nsf/dx/19.06.2024110207KLECLW.htm</guid>
<content:encoded><![CDATA[ On my endless path of reinventing the wheel regarding Domino APIs, my latest adventure has once again led me to find efficient and powerful ways to query Domino data. For many years, this topic has been a pain point for me. Back in the IBM Design Partner program, I wrote many entries in the discussions database, asking IBM core development for better and faster ways to read Domino data. View traversal speed In the old days, according to Domino core developers, there was no priority for LotusScript or Java API methods to read data as fast as possible, "since most of the code was running at night in agents anyway" (that is what they told me). Things changed a bit when XPages were introduced in 2009. Core development began to tweak the codebase for performance, for example, to not just read one view row at a time in the ViewNavigator API, since the underlying C API call NIFReadEntries has never had this restriction. It has others; the return data buffer has a max size of 64K, but depending on the type of view data, this buffer can contain lots of rows. For example, if you just read note IDs (4 bytes each), one NIFReadEntries call returns about 16,000 rows at once. New API methods like ViewNavigator.setBufferMaxEntries(...) and ViewNavigator.setCacheGuidance(...) were the result. They sped up view traversal A LOT. Unfortunately, Domino core development thought there was no need to ever write documentation for them. Check for yourself: Go into your Domino Designer help and try to find information about these methods, same with a Google search. At least you will find a few community blogs (like ours) that wrote about this topic and how to use these methods. This <a href=https://youtu.be/rTmxIZjeoJ8 target=_blank>video</a> on YouTube might also help. Data consistency In addition to faster view traversal, Domino core development also started working on ways to read view data more consistently and better handle concurrent data updates. Compared to SQL databases or more modern NoSQL databases like CouchDB, Domino has always had poor data consistency. Although transaction support has existed in the Domino API since Domino 12, these transactions can only be used to modify multiple database documents atomically. They do not cover reading data from views. For example, if you want to read all view rows matching a lookup key using the publicly available C API methods, you would open the view (NIFOpenCollection), find the position of the first row matching the lookup key and determine the number of matches (NIFFindByKey, which returns a position like "1.2.3"), and start reading row data at that position (using one or more NIFReadEntries calls, depending on how much row data fits into the 64K buffer). These are three separate C API calls. The view index that you are working on is NOT your private copy. So, if other users change data at the same time and the view indexer kicks in, things become challenging. To be fair, you receive signals from NIFReadEntries (e.g., SIGNAL_ANY_CONFLICT) indicating that the view index or view design has changed in the meantime. This means that your start position "1.2.3" might be completely wrong. If you know the note ID that your code read last in addition to its position, NIFLocateNote might be handy. It tries to find the new position of this row "nearby." However, it's possible that this exact document no longer matches the lookup key and has been moved somewhere else in the view. Instead, you could re-run your lookup repeatedly until none of the NIFReadEntries calls signal a view index change. If only there were a way to prevent view index updates while lookups were running! NIFFindByKeyExtended2 to the rescue The C API of Domino 12 exposed a new method, NIFFindByKeyExtended2, which had been added to Domino years earlier. NIFFindByKeyExtended2 combines NIFFindByKey and the first NIFReadEntries call in an atomic manner. This means that the view index is locked, ensuring data consistency, at least if you don't have more than 16,000 rows for the same lookup key, or significantly fewer rows if you are also reading the column values (e.g., in one of our applications, only 70 rows filled the entire 64K buffer). I am not a C developer! Do I have to care? Life as a LotusScript or Java developer on Domino is easier than for C developers. You just call View.getAllDocumentsByKey(...) or View.getDocumentByKey(...), and the black magic happens under the covers. These methods have been using NIFFindByKeyExtended2 internally for many years, I think since R9 (or the undocumented NIFFindByKeyExtended3, which returns the result in a callback). There is a small chance that the document in the returned DocumentCollection might have changed in the meantime and no longer matches the lookup key that produced the DocumentCollection. As a paranoid person, you could check this. But as soon as the document is loaded and concurrent updates to it happen, you get a save error and can decide in your code if you want to reload the document or create a save conflict. I use View.setAutoUpdate(false), does this help to get consistent view data? In short: no. There is an old article in the Domino development wiki (<a href="https://ds-infolib.hcltechsw.com/ldd/ddwiki.nsf/dx/View.AutoUpdate_?OpenDocument&sa=true">https://ds-infolib.hcltechsw.com/ldd/ddwiki.nsf/dx/View.AutoUpdate_?OpenDocument&sa=true</a>) which explains the AutoUpdate flag. It just changes the strategy how the API recovers in case of view index changes: AutoUpdate=true means "use NIFLocateNote and go on reading at the new position". AutoUpdate=false means "don't care, just go on reading at the current position" The same applies for LotusScript/Java as for C - you don't get a private copy of the view index. So things can change all the time and they sometimes shine through when using the LotusScript/Java API: NotesException: Notes error: Entry not found in index (Articles\Latest Issue)         at lotus.domino.local.ViewNavigator.NgotoEntry(Native Method)         at lotus.domino.local.ViewNavigator.gotoX(Unknown Source)         at lotus.domino.local.ViewNavigator.gotoChild(Unknown Source)         at lotus.domino.local.ViewNavigator.getChild(Unknown Source) NotesException: Notes error: Entry not found in index (Articles\Quota Computation)         at lotus.domino.local.ViewNavigator.NgotoEntry(Native Method)         at lotus.domino.local.ViewNavigator.gotoX(Unknown Source)         at lotus.domino.local.ViewNavigator.gotoNextSibling(Unknown Source)         at lotus.domino.local.ViewNavigator.getNextSibling(Unknown Source) Here, the ViewNavigator is trying to change the cursor position and notices that the view index has changed in a way that it cannot recover. These are actual exceptions from production apps. By using setBufferMaxEntries() / setCacheGuidance(), these errors might happen less often, because the next children or sibling entries are already precached in the buffer. But the ViewNavigator precaching is only working with AutoUpdate=false and the cache is invalidated when you change navigation direction. When the ViewNavigator then runs out of cache entries, it does not care about view index changes and consistency. Hooray. What about DQL? Does that help? In short: yes. When using DQL, it is HCL's responsibility to ensure data consistency during view lookups, FT searches, or NSF scans with a search formula. The DQL engine returns matches as an IDTable for C developers (compressed storage of note IDs), which the LotusScript/Java API translates into a DocumentCollection. This translation is slower because it unnecessarily loads each document even if you only need the note IDs. If you believe you have found an example of data inconsistency, create a reproducible test case and submit a support ticket. Cliffhanger :-) In the next article, I will discuss the new QueryResultsProcessor in Domino 12, covering its capabilities and limitations. I will also explain how I rebuilt cross-database Domino view indexing in Domino JNA from scratch, avoiding these limitations. So stay tuned. ]]></content:encoded>
<wfw:commentRss> https://www.mindoo.com/web/blog.nsf/dxcomments/19.06.2024110207KLECLW.htm</wfw:commentRss>
<wfw:comment> https://www.mindoo.com/web/blog.nsf/dx/19.06.2024110207KLECLW.htm?opendocument&comments</wfw:comment>
</item>
<item>
<title>Configure Eclipse 4.6.x with HCL Notes 12.0.1 FP1</title>
<pubDate>Fri, 18 Nov 2022 22:29:22 +0200</pubDate>
<description>
<![CDATA[
Once again I had to ask HCL development for setup instructions how to launch the HCL Notes Standard Client from an Eclipse IDE, this time for Notes 12.0.1 FP1. The instructions I had gotten earlier f ...
]]>
</description>
<link>https://www.mindoo.com/web/blog.nsf/dx/18.11.2022222922KLET7X.htm</link>
<category>Eclipse</category>
<dc:creator>Karsten Lehmann</dc:creator>
<comments>https://www.mindoo.com/web/blog.nsf/dx/18.11.2022222922KLET7X.htm?opendocument&comments</comments>
<guid isPermaLink="true">https://www.mindoo.com/web/blog.nsf/dx/18.11.2022222922KLET7X.htm</guid>
<content:encoded><![CDATA[ Once again I had to ask HCL development for setup instructions how to launch the HCL Notes Standard Client from an Eclipse IDE, this time for Notes 12.0.1 FP1. The instructions I had gotten earlier for Notes 10 have not changed much (I think there's one additional VM argument at the end of the list), but enough so that they did not work anymore. The document links to Eclipse Neon 4.6.3, but it's still working for me in later versions, I tried it with Eclipse 2020-09 (4.17.0, 64 bit). I used my local installation directory in the text below (C:\Program Files (x86)\HCL\Notes) and the plugin version for com.ibm.rcp.base in Notes 12.0.1 FP1. Of course these need to match your local environment. 1. Download Eclipse Neon (4.6.3) or later from link below: <a href="http://www.eclipse.org/downloads/download.php?file=/technology/epp/downloads/release/neon/3/eclipse-committers-neon-3-win32-x86_64.zip" target=_blank>http://www.eclipse.org/downloads/download.php?file=/technology/epp/downloads/release/neon/3/eclipse-committers-neon-3-win32-x86_64.zip</a> 2. Get HCL Notes 12.0.1 FP1 I used the instructions with the 32 bit Notes Client so far. 3. Go to Windows => Preferences => Java => Installed JREs <ul> <li>Add => Standard VM => </li><li>JRE home: <code>C:\Program Files (x86)\HCL\Notes\jvm</code> </li><li>JRE name: â\x80\x9cNotes JREâ\x80\x9d </li><li>Select the JRE to point to this and Apply</li></ul> 4. Go to Windows => Preferences => Plug-in Development => Target Platform <ul> <li>Add => default => Target Content </li><li>Name: â\x80\x9cNotes Targetâ\x80\x9d</li></ul> 4a. In Locations Tab: <ul> <li>Add => Directory => Location => <code>C:\Program Files (x86)\HCL\Notes\framework\rcp\eclipse\plugins</code> </li><li>Add => Directory => Location => <code>C:\Program Files (x86)\HCL\Notes\framework\shared\eclipse\plugins</code> </li><li>Finish </li><li>Select the Target platform to point to â\x80\x9cNotes Targetâ\x80\x9d and Apply</li></ul> 4 b. In Content Tab: <ul> <li>go through the plugin list </li><li>for duplicate plugins, deactivate the older one </li><li>only relevant if you have installed a fixpack</li></ul> 4 c. In Environment Tab: Please select following settings: <ul> <li>Operating System: win32 </li><li>Windowing System: win32 </li><li>Architecture: x86 </li><li>Locale: en_US - English (United States)</li></ul> 5. Go to Windows => Preferences => Run/Debug => String Substitution New => Add 2 strings (change plugin version and path based on your setup) 5a. Name: rcp_home Value: <code>C:\Program Files (x86)\HCL\Notes\framework</code> 5b. Name: rcp_base Value: <code>C:\Program Files (x86)\HCL\Notes\framework\rcp\eclipse\plugins\com.ibm.rcp.base_10.0.0.20211117-0921</code> OK Close this Preferences Window 6. Put the following file inside the below plugin: <code>C:\Program Files (x86)\HCL\Notes\framework\rcp\eclipse\plugins\com.ibm.rcp.base_10.0.0.20211117-0921</code> <a href="https://www.mindoo.com/web/blog.nsf/dx/rcp.security.properties/$file/rcp.security.properties" target="_blank" title="rcp.security.properties">rcp.security.properties</a> 7. Open Debug Configurations in the â\x80\x98Debug Perspectiveâ\x80\x99 => Eclipse Configuration => New 7a. In the Main tab: Name: NotesDebug Program to Run =>  Run a product => <code>com.ibm.notes.branding.notes</code> Java Runtime Environment => Runtime JRE => Select â\x80\x9cNotes JREâ\x80\x9d i.e. the one we added in step 3 7b. In the Arguments tab: Program Arguments: <code>-clean -console -debug -log -personality com.ibm.rcp.platform.personality -config notes</code> VM Arguments: <code>-Xquickstart -Xss384k -Xshareclasses -Drcp_home="${rcp_home}" -Drcp.install.config=user -Dosgi.install.area="${rcp_home}\eclipse" -Disa.ignoreESR=true -Dcom.ibm.pvc.osgiagent.core.logfileloc="${rcp_home}\rcp" -Dcom.ibm.pvc.webcontainer.port=0 -Declipse.pluginCustomization="${rcp_home}\rcp\plugin_customization.ini" -Djava.security.properties="${rcp_base}\rcp.security.properties" -Declipse.registry.nulltoken=true -Djava.protocol.handler.pkgs=com.ibm.net.ssl.www.protocol -Djava.util.logging.config.class=com.ibm.rcp.core.internal.logger.boot.LoggerConfig -Dosgi.hook.configurators.exclude=org.eclipse.core.runtime.internal.adaptor.EclipseLogHook -Dosgi.framework.extensions=com.ibm.rcp.core.logger.frameworkhook,com.ibm.rds,com.ibm.cds "-Xbootclasspath/a:${rcp_base}\rcpbootcp.jar" -Xdump:system:events=user</code> 8. Apply => Debug â\x80\x93 This will launch your Notes in Debug mode. Ensure that whenever you launch the Notes from Eclipse, there should be no other instance of Notes already running. If so, please close Notes and then launch from Eclipse to debug. ]]></content:encoded>
<wfw:commentRss> https://www.mindoo.com/web/blog.nsf/dxcomments/18.11.2022222922KLET7X.htm</wfw:commentRss>
<wfw:comment> https://www.mindoo.com/web/blog.nsf/dx/18.11.2022222922KLET7X.htm?opendocument&comments</wfw:comment>
</item>
<item>
<title>New release of Open Eclipse Update Site to fix issues with Win/64 Notes Client 12.0.2</title>
<pubDate>Thu, 17 Nov 2022 23:24:41 +0200</pubDate>
<description>
<![CDATA[
As Jesse blogged there are some issues in the new Windows 64 Bit Notes Client 12.0.2 that break the "Import Local Update Site" functionality of the standard Update Site template of Domino. To fix thi ...
]]>
</description>
<link>https://www.mindoo.com/web/blog.nsf/dx/17.11.2022232441KLEUAH.htm</link>
<category>DDE</category>
<dc:creator>Karsten Lehmann</dc:creator>
<comments>https://www.mindoo.com/web/blog.nsf/dx/17.11.2022232441KLEUAH.htm?opendocument&comments</comments>
<guid isPermaLink="true">https://www.mindoo.com/web/blog.nsf/dx/17.11.2022232441KLEUAH.htm</guid>
<content:encoded><![CDATA[ As <a href="https://frostillic.us/blog/posts/2022/11/17/notes-domino-12-0-2-fallout" target=_blank>Jesse blogged</a> there are some issues in the new Windows 64 Bit Notes Client 12.0.2 that break the "Import Local Update Site" functionality of the standard Update Site template of Domino. To fix this and other issues, I just uploaded a new release of the <a href="https://www.openntf.org/main.nsf/project.xsp?r=project/Open%20Eclipse%20Update%20Site/releases/8AC6CDB1EC752629862588FD007AA5F0" target=_blank>Open Eclipse Update Site</a> on OpenNTF. Here is the fixlist:   <ul> <li>This release fixes LS errors in the new Windows 12.0.2 64 Bit client that occur because LS tries to load SWT Java classes, but they do not seem to be available in the Windows 64 Bit client (same for Mac/64 which had already been fixed in earlier releases). </li><li>In addition we fixed feature deletion. You can now delete disabled features, not just enabled features like in 1.1. </li><li>"IBM" has been replaced with "HCL" in several areas to match the current R11 standard Update Site template of Domino. </li><li>broken links in the about/using this database pages have been fixed</li></ul> ]]></content:encoded>
<wfw:commentRss> https://www.mindoo.com/web/blog.nsf/dxcomments/17.11.2022232441KLEUAH.htm</wfw:commentRss>
<wfw:comment> https://www.mindoo.com/web/blog.nsf/dx/17.11.2022232441KLEUAH.htm?opendocument&comments</wfw:comment>
</item>
<item>
<title>Java class line numbers for plugin developers</title>
<pubDate>Tue, 25 Oct 2022 10:32:42 +0200</pubDate>
<description>
<![CDATA[
This is a shameless copy of Mikkel Heisterberg's blog article (https://lekkimworld.com/2010/04/14/java-class-line-numbers-for-plugin-developers/) to have this helpful information twice in the Google i ...
]]>
</description>
<link>https://www.mindoo.com/web/blog.nsf/dx/25.10.2022103242KLEC2H.htm</link>
<category></category>
<dc:creator>Karsten Lehmann</dc:creator>
<comments>https://www.mindoo.com/web/blog.nsf/dx/25.10.2022103242KLEC2H.htm?opendocument&comments</comments>
<guid isPermaLink="true">https://www.mindoo.com/web/blog.nsf/dx/25.10.2022103242KLEC2H.htm</guid>
<content:encoded><![CDATA[ This is a shameless copy of Mikkel Heisterberg's blog article (<a href="https://lekkimworld.com/2010/04/14/java-class-line-numbers-for-plugin-developers/">https://lekkimworld.com/2010/04/14/java-class-line-numbers-for-plugin-developers/</a>) to have this helpful information twice in the Google index and save me time when I need it in the future. :-) Hiding line numbers in stacktraces for performance reasons is pretty high on my top list of the most stupid ideas in Notes/Domino history. <hr> If youâ\x80\x99ve been tasked with developing and/or debugging Java extensions for the Notes 8 client you know that line numbers has been missing from the stacktraces produced by Notes. This can be a real problem when trying to debug stuff in a production client. There has been some discussion among the ones of us developing these extensions on how to enable these line numbers. The other day this information was provided by Srinivas Rao of IBM and I wanted to publish it here for all to read. Line numbers are removed from the classes added to the shared class cache to reduce the memory needed for the memory mapped classes. To re-enable the line numbers, one needs to edit the <notes>frameworkrcpdeployjvm.properties file and add comment out the ignorelinenumbers vm argument. However, if the classes have already been added to the JVM shared class cache, then they will have been added without line numbers. Either comment out the shared class cache (which will dramatically affect performance at startup) for temporary work, or shutdown notes and remove the shared class cache so that it can be repopulated with classes with line numbers. Of course, this will also affect the startup performance, but not so much as not having a cache These are two of the key lines â\x80¦ to comment them out, add a # to the front of the line <code>vmarg.Xnolinenumbers=-Xnolinenumbers</code> <code>vmarg.Dshare=-Xshareclasses:name=xpdplat_.jvm, **line cont**</code> <code>   controlDir=${prop.jvm.shareclasses.loc}, **line cont**</code> <code>   groupAccess,keep,singleJVM,nonfatal</code> <code>jvm.shareclasses.loc=${rcp.data}/.config/org.eclipse.osgi</code> The shared class cache is typically located in the data/workspace/.config/org.eclipse.osgi ]]></content:encoded>
<wfw:commentRss> https://www.mindoo.com/web/blog.nsf/dxcomments/25.10.2022103242KLEC2H.htm</wfw:commentRss>
<wfw:comment> https://www.mindoo.com/web/blog.nsf/dx/25.10.2022103242KLEC2H.htm?opendocument&comments</wfw:comment>
</item>
<item>
<title>Domino crashes with "CheckTheProcesses" message - explanation and workaround for dev environments</title>
<pubDate>Wed, 13 Jul 2022 10:10:42 +0200</pubDate>
<description>
<![CDATA[
Since Domino 8.5.3, there is a built-in facility that checks if all server processes are running. When the server detects that one has disappeared/crashed, the server triggers an NSD to document this ...
]]>
</description>
<link>https://www.mindoo.com/web/blog.nsf/dx/13.07.2022101042KLEBLS.htm</link>
<category>Notesdev</category>
<dc:creator>Karsten Lehmann</dc:creator>
<comments>https://www.mindoo.com/web/blog.nsf/dx/13.07.2022101042KLEBLS.htm?opendocument&comments</comments>
<guid isPermaLink="true">https://www.mindoo.com/web/blog.nsf/dx/13.07.2022101042KLEBLS.htm</guid>
<content:encoded><![CDATA[ Since Domino 8.5.3, there is a built-in facility that checks if all server processes are running. When the server detects that one has disappeared/crashed, the server triggers an NSD to document this event and crashes/restarts. In general, this is a clean approach to keep the server in a consistent state. But when you develop Java applications against the Domino Server's Java API, those Java processes are treated as child processes and monitored as well It's important to develop the applications in a clean way, so every Thread accessing Domino objects should be initialized with <tt>NotesThread.sinitThread()</tt> and properly uninitialized with <tt>NotesThread.stermThread()</tt>. To ensure that this is also the case when errors occur in code, use try/finally: <tt>NotesThread.sinitThread();</tt> <tt>Session session = null;</tt> <tt>try {</tt> <tt>   session = NotesFactory.createSession();</tt> <tt>   // do something with the session object</tt> <tt>}</tt> <tt>catch (NotesException e) {</tt> <tt>   e.printStackTrace();</tt> <tt>}</tt> <tt>finally {</tt> <tt>   if (session!=null) {</tt> <tt>      try { session.recycle(); } catch (NotesException e) {e.printStackTrace();}</tt> <tt>   }</tt> <tt>   NotesThread.stermThread();</tt> <tt>}</tt> This works in general, but often during development, you step through the code in debugger and just stop its execution, which produces this annoying result: <img alt="Image:Domino crashes with "CheckTheProcesses" message - explanation and workaround for dev environments" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/13.07.2022101042KLEBLS.htm/content/M2?OpenElement" /> Fortunately it is possible disable the automatic Domino crash/restart with this Notes.ini variable: <tt>NO_TERM_EXIT_NO_PANIC=1</tt> The server still complains about the missing child process, but keeps on running. Of course, it would be even better if there was a way to exclude specific processes/process names from the monitoring. ]]></content:encoded>
<wfw:commentRss> https://www.mindoo.com/web/blog.nsf/dxcomments/13.07.2022101042KLEBLS.htm</wfw:commentRss>
<wfw:comment> https://www.mindoo.com/web/blog.nsf/dx/13.07.2022101042KLEBLS.htm?opendocument&comments</wfw:comment>
</item>
<item>
<title>Domino JNA version 0.9.48: API to read/write Notes workspace, some formula magic and QueryResultsProcessor API</title>
<pubDate>Wed, 1 Jun 2022 00:43:40 +0200</pubDate>
<description>
<![CDATA[
Today we released version 0.9.48 of Domino JNA as OSGi plugin for XPages developers and on Maven Central. Here is a list of new features: API to read and write the Notes workspace (read, create an ...
]]>
</description>
<link>https://www.mindoo.com/web/blog.nsf/dx/01.06.2022004339KLEUND.htm</link>
<category>Domino C API</category>
<dc:creator>Karsten Lehmann</dc:creator>
<comments>https://www.mindoo.com/web/blog.nsf/dx/01.06.2022004339KLEUND.htm?opendocument&comments</comments>
<guid isPermaLink="true">https://www.mindoo.com/web/blog.nsf/dx/01.06.2022004339KLEUND.htm</guid>
<content:encoded><![CDATA[ Today we released version 0.9.48 of <a href="https://github.com/klehmann/domino-jna" target=_blank>Domino JNA</a> as OSGi plugin for XPages developers and on Maven Central. Here is a list of new features: <ul> <li>API to read and write the Notes workspace (read, create and modify pages and icons, change page order, move replicas on top etc.) </li><li>Formula execution now supports more than 64k of return data </li><li>API to apply security to formula execution (e.g. prevent Notes.ini changes) </li><li>API for QueryResultsProcessor (produces JSON and views) </li><li>Java 8 date/time support for NotesNote.replaceItemValue(...) </li><li>New utility class to format view data as markdown table </li><li>Added method to get agent design doc UNID </li><li>Added hierarchical recycling (parent/child auto recycle)</li></ul> Notes Workspace API The new Notes workspace API is pretty feature complete. It let's you read and modify the workspace content and contains functionality that I have long been waiting for in the Notes Client user interface like a method to change the order of tabs. Actually I built this for my own purpose because I needed a tool to remove icons that no longer exist. To play with the API and as a sample for a standalone application using Domino JNA, I created a small Maven project that you can find here: <a href="https://github.com/klehmann/domino-jna/tree/develop/workspace-demo">https://github.com/klehmann/domino-jna/tree/develop/workspace-demo</a> The application creates a new workspace page: <img alt="Image:Domino JNA version 0.9.48: API to read/write Notes workspace, some formula magic and QueryResultsProcessor API" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/01.06.2022004339KLEUND.htm/content/M2?OpenElement" /> and a database icon with a red rectangle: <img alt="Image:Domino JNA version 0.9.48: API to read/write Notes workspace, some formula magic and QueryResultsProcessor API" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/01.06.2022004339KLEUND.htm/content/M3?OpenElement" /> We support both the classic 32x32 pixel icons and the new 64x64 true color ones. By passing a NotesDatabase object to NotesWorkspace.addIcon(...), the current DB icon gets extracted from the NSF design and copied into the workspace. Please make sure that the Notes Client is not running or in its early startup phase when you modify the workspace. Otherwise the changes will not be visible in the Notes UI and might later be overwritten. Formula magic Classic formula execution is limited to 64K of return data. We found a way to remove this limit (e.g. to use @DbColumn to read the whole column of a view) and you can even run formulas in a restricted environment, e.g. to prevent them from changing the Notes.ini or setting document items. Methods have been added to analyze a formula in order to see if it's time variant, just contains a field name or uses special functions like @DocSiblings or @DocDescendants. QueryResultsProcessor API The <a href="https://jdcurtis.blog/2021/11/29/the-query-results-processor-part-one/" target=_blank>QueryResultsProcessor</a> lets you build views across NSF boundaries, have them displayed in the Notes Client or exported in JSON format as string. In contrast to the implementation in the legacy Notes.jar and LotusScript API, we provide methods to get the JSON result back in a streaming way so that it can be parsed without storing the whole content in the Java heap. ]]></content:encoded>
<wfw:commentRss> https://www.mindoo.com/web/blog.nsf/dxcomments/01.06.2022004339KLEUND.htm</wfw:commentRss>
<wfw:comment> https://www.mindoo.com/web/blog.nsf/dx/01.06.2022004339KLEUND.htm?opendocument&comments</wfw:comment>
</item>
<item>
<title>Chad Schelfhout’s toolbar code to change document properties</title>
<pubDate>Tue, 26 Apr 2022 11:10:22 +0200</pubDate>
<description>
<![CDATA[
I just noticed that Chad Schelfhout's website is no longer available, that contained formula code for a toolbar icon to read/edit document properties. So here it is to not get lost - the latest versio ...
]]>
</description>
<link>https://www.mindoo.com/web/blog.nsf/dx/26.04.2022111021KLECS3.htm</link>
<category></category>
<dc:creator>Karsten Lehmann</dc:creator>
<comments>https://www.mindoo.com/web/blog.nsf/dx/26.04.2022111021KLECS3.htm?opendocument&comments</comments>
<guid isPermaLink="true">https://www.mindoo.com/web/blog.nsf/dx/26.04.2022111021KLECS3.htm</guid>
<content:encoded><![CDATA[ I just noticed that Chad Schelfhout's website is no longer available, that contained formula code for a toolbar icon to read/edit document properties. So here it is to not get lost - the latest version I have. Please note that the Notes Client 12 contains Panagenda's Advanced Properties Box plugin to read and compare document properties. And Daniel Nashed describes how to get an extended version of the plugin that supports editing as well: <a href="https://blog.nashcom.de/nashcomblog.nsf/dx/advanced-document-properties-including-edit.htm" target=_blank>https://blog.nashcom.de/nashcomblog.nsf/dx/advanced-document-properties-including-edit.htm</a> So the code below is probably only relevant anymore for older Notes Client installs or the Basic Client. REM {Edit Document Fields 6.0.0 by Chad Schelfhout.}; REM {Visit <a href=http://www.chadsmiley.com/EditDocumentFields>http://www.chadsmiley.com/EditDocumentFields</a> for the latest updates}; REM {Changable constants}; cEnableConfirmation := @True; cFieldHistoryValues := 10; cStandardSeparators := ":" : ";" : " "; cPromptTitle :@DbTitle + " - " + @ViewTitle; REM {Unchangable constants}; cProfileName :"ChadSmiley Tools"; cEditLastField := "edfLastField"; cEditLastFieldDataType := "edfLastFieldDataType"; cEditLastFieldDataTypeValue := "edfLastFieldDataTypeValue"; cEditLastSeparator := "%~%"; cValueListSeparator := "^"; cFromRawValueSeparator := "%@%"; cSemicolonReplace := "#SC#"; cMaxSearchForSelectedDocs := 5520; cMaxUpdatedDocuments := 1000; cArraySeparator := ";"; cNoteEntryLength := 11; cPromptNewLineOne := @Char(13); cPromptNewLineTwo := cPromptNewLineOne + cPromptNewLineOne; cPromptTab :@Char(9); cCategoryNoteID := "NT00000000"; cTextExtractList := "Text Left":"Text Left Back":"Text Right":"Text Right Back"; cNoPromptList := cTextExtractList:"Remove Field":"Unique":"Sort Ascending":"Sort Descending":"Implode":"Explode":"Proper Case Text":"Proper Case Text Multi Value":"Lower Case Text":"Lower Case Text Multi Value":"Upper Case Text":"Upper Case Text Multi Value":"Password Convert":"Trim":"Trim then Unique"; cErrorCheckCode := "@Implode( @Unique( @Explode( NoteIDList : ErrorNoteID ; cArraySeparator ; @False ) ) )"; cErrorInformation := "\"Error documents: \" + @Implode( @Unique( @Explode( ErrorNoteIDList ; cArraySeparator ; @False ) ) ; \", \" ) + cPromptNewLineOne + \"Not updated documents: \" + @Implode( @Unique( @Explode( ErrorNoteIDList ; cArraySeparator ; @False ) ) ; \", \" )"; REM {Data types|@Function execution}; DataTypesCombo := @Explode( "Integer|@TextToNumber( RawValue )$"+ "Integer Multi Value|@TextToNumber( @Explode( RawValue ; Separator; @True) )$"+ "Date|@ToTime( RawValue )$"+ "Date Multi Value|@ToTime( @Explode( RawValue ; Separator; @True) )$"+ "Text|@Text( RawValue )$"+ "Text Multi Value|@Text( @Explode( RawValue ; Separator; @True) )$"+ "Text Left|@Left( @Text( @GetField( EditField[ef] ) ) ; ExtractValue )$"+ "Text Left Back|@LeftBack( @Text( @GetField( EditField[ef] ) ) ; ExtractValue )$"+ "Text Right|@Right( @Text( @GetField( EditField[ef] ) ) ; ExtractValue )$"+ "Text Right Back|@RightBack( @Text( @GetField( EditField[ef] ) ) ; ExtractValue )$"+ "Trim|@Trim( @Text( @GetField( EditField[ef] ) ) )$"+ "Trim then Unique|@Unique(@Trim( @Text( @GetField( EditField[ef] ) ) ) )$"+ "Name|RawValue$"+ "Name Multi Value|RawValue$"+ "Common Name|@Name( [CN]; RawValue )$"+ "Common Name Multi Value|@Name( [CN]; @Explode( RawValue ; \":\"; @True ) )$"+ "Upper Case Text|@UpperCase( @Implode( @Text( @GetField( EditField[ef] ) ) ) )$"+ "Lower Case Text|@LowerCase( @Implode( @Text( @GetField( EditField[ef] ) ) ) )$"+ "Proper Case Text|@ProperCase( @Implode( @Text( @GetField( EditField[ef] ) ) ) )$"+ "Upper Case Text Multi Value|@UpperCase( @Explode( @Text( @GetField( EditField[ef] ) ) ; Separator; @True ))$"+ "Lower Case Text Multi Value|@LowerCase( @Explode( @Text( @GetField( EditField[ef] ) ) ; Separator; @True) )$"+ "Proper Case Text Multi Value|@ProperCase( @Explode( @Text( @GetField( EditField[ef] ) ) ; Separator; @True) )$"+ "Replace Substring|@ReplaceSubstring( @GetField( EditField[ef] ); FromRawValue ; RawValue )$"+ "Replace|@Explode( @Replace( @GetField( EditField[ef] ) ; FromRawValue ; RawValue ) ; Separator ; @True )$"+ "Implode|@Implode( @Text( @GetField( EditField[ef] ) ) ; Separator )$"+ "Explode|@Explode( @Text( @GetField( EditField[ef] ) ) ; Separator; @True )$"+ "Formula|@Eval( RawValue )$"+ "Abbreviate Name|@Name([Abbreviate]; RawValue )$"+ "Abbreviate Name Multi Value|@Name( [Abbreviate]; @Explode( RawValue ; Separator; @True ) )$"+ "Password Set|@Password( RawValue )$"+ "Password Convert|@Password( @GetField( EditField[ef] ) )$"+ "Remove Field|@DeleteField$"+ "Unique|@Unique(@GetField( EditField[ef]))$"+ "+ Append Values|@If(" + "     @GetField(EditField[ef]) = \"\"; RawValue;" + "     @Contains(DefaultDataType; \"Date\");" + "      @If( @IsError( @ToTime( RawValue ) ) ;" + "       \"\" ;" + "       @SetField( EditField[ef] ; @GetField(EditField[ef]) : @TextToTime( @Explode( RawValue ; Separator ) ) ) ) ;" + "     @Contains(DefaultDataType; \"Integer\" );" + "      @If( @IsError( @TextToNumber( @Explode( RawValue ; Separator ) ) ) ;" + "       \"\" ;" + "       @SetField( EditField[ef] ; @GetField(EditField[ef]) : @TextToNumber( @Explode( RawValue ; Separator ) ) ) ) ;" + "     @SetField( EditField[ef] ; @GetField(EditField[ef]) : @Explode( RawValue ; Separator ) ) )$"+ "Sort Ascending|@Sort(@GetField(EditField[ef]) ; [Ascending] )$"+ "Sort Descending|@Sort(@GetField(EditField[ef]); [Descending])" ; "$" ); DataTypes := @Word( DataTypesCombo ; "|" ; 1 ); DataTypesAction := @Word( DataTypesCombo ; "|" ; 2 ); REM {Get a listing of all the fields on the current document}; List := @Sort( @DocFields ); REM {Look for last field modified in Profile Doc}; FieldList := @Explode( @GetProfileField( cProfileName ; cEditLastField ; @UserName ) ; cArraySeparator ; @True ) ; REM {Get the list of forms and field that was updated using Edit Document Fields}; FieldListForms := @Word( FieldList ; cEditLastSeparator ; 1 ); FieldListField := @Word( FieldList ; cEditLastSeparator ; 2 ); FieldListLastIndex := @Member( Form; FieldListForms ); REM {If the FieldListLastIndex is greater than zero then set the last field to the what was in the profile document}; @If( FieldListLastIndex > 0;  @Do( LastField := FieldListField[ FieldListLastIndex ];   FieldList := @ReplaceSubstring( FieldList ; FieldList[ FieldListLastIndex ] ; "" ) );  LastField :="" ); REM {Prompt for which field needs to be updated. Loop until a field is selected or 'Cancel' is selected}; @DoWhile(  EditField := @Prompt( [OkCancelEditCombo] ; cPromptTitle ; "Select the field you wish to alter or enter a new field to add:" ; LastField ; @Trim( @Unique( List : LastField ) ) );  EditField = "" ); EditFieldPromptTitle := "Change '" + EditField + "' in " + cPromptTitle; REM {This will allow the retrieval of the data type of the field that was last selected. Data is stored like Form+Field%~%DataType.}; FormFieldList := @Explode( @GetProfileField( cProfileName ; cEditLastFieldDataType ; @UserName ) ; cArraySeparator ; @True ) ; FormFieldListFormField := @Word( FormFieldList ; cEditLastSeparator ; 1 ); FormFieldListDataType := @Word( FormFieldList ; cEditLastSeparator ; 2 ); FormFieldListFormulaCode := @ReplaceSubstring( @Word( FormFieldList ; cEditLastSeparator ; 3 ) ; cSemicolonReplace ; ";" ); FormFieldListIndex := @Member( Form + EditField; FormFieldListFormField ); @If( FormFieldListIndex > 0;  @Do( DefaultDataType := FormFieldListDataType[ FormFieldListIndex ];   FormFieldListFormulaCode := FormFieldListFormulaCode[ FormFieldListIndex ];   FormFieldList := @ReplaceSubstring( FormFieldList ; FormFieldList[ FormFieldListIndex ] ; "" ) );  DefaultDataType :="" ); REM {If there was no data type used for the field on the form the try to determine the data type}; DefaultDataType :=  @If( DefaultDataType != "" ;   DefaultDataType ;   @If(    @IsNumber( @GetField( EditField ) ) ;     @If( @Count( @GetField( EditField ) ) > 1 ;      "Integer Multi Value" ;      "Integer" ) ;    @IsTime( @GetField( EditField ) ) ;     @If( @Count( @GetField( EditField ) ) > 1 ;      "Date Mult iValue" ;      "Date" ) ;    @If( @Count( @GetField( EditField ) ) > 1 ;      "Text Multi Value" ;      "Text" )    )  ); REM {If the data type is a type of error then select the data type of text}; DefaultDataType := @IfError( DefaultDataType ; "Text" ); REM {Prompt for which data type you would like the data to be. This needs to be done before value prompt to determine if the Picklist or any prompting needs to be used.}; DataType := @Prompt( [OkCancelList] ; EditFieldPromptTitle; "Please select the correct data type or action for field: " + EditField + "."; DefaultDataType ; DataTypes ); REM {The DataTypeAction will contain the formula that will be executed to retrieve the new value}; DataTypeAction := DataTypesAction[ @Member( DataType ; DataTypes ) ]; REM {If formula was used on this field then use that instead of the fields value. Format the original value as text because the @Prompt command requires text.}; OriginalValue := @If( DataType = "Formula" & DefaultDataType = "Formula" & FormFieldListFormulaCode != "" ;  FormFieldListFormulaCode ;  @If( @Contains( DefaultDataType ; MultiValue ) ;   @Implode( @Text( @GetField( EditField ) ) ; cArraySeparator );   @Text( @GetField( EditField ) ) )  ); REM {This will allow the retrieval of history of values of the field. Data is stored like Form+Field+DataType%~%ValueList.}; FormFieldListDataTypeValues := @Explode( @GetProfileField( cProfileName ; cEditLastFieldDataTypeValue ; @UserName ) ; cArraySeparator ; @True ) ; FormFieldListFormFieldDataType := @Word( FormFieldListDataTypeValues ; cEditLastSeparator ; 1 ) ; FormFieldListValuesLists := @Word( FormFieldListDataTypeValues ; cEditLastSeparator ; 2 ) ; FormFieldListDTIndex := @Member( Form + EditField + DataType; FormFieldListFormFieldDataType ); @If( FormFieldListDTIndex > 0;  @Do( FormFieldListValuesList := FormFieldListDataTypeValues[ FormFieldListDTIndex ];   FormFieldListValuesList := @ReplaceSubstring( @Trim( @Explode( FormFieldListValuesLists[ FormFieldListDTIndex ] ; cValueListSeparator ; @False ) ) ; cSemicolonReplace; ";" );   FormFieldListDataTypeValues := @ReplaceSubstring( FormFieldListDataTypeValues ; FormFieldListDataTypeValues[ FormFieldListDTIndex ] ; "" ) );  FormFieldListValuesList :="" ); REM {Prompt for additional fields and determine the string that they are searching for.}; @If( DataType = ("Replace Substring":"Replace" ) ;  @Do( EditField := @Unique( EditField : @Prompt( [OkCancelListMult] ; cPromptTitle ; "Select any addtional fields you wish to alter:" ; EditField ; List ) );   FromRawValue := @Prompt( [OkCancelEditCombo] ; EditFieldPromptTitle ; "Enter or select the text (case sensitive) to search for in: " + @Implode( EditField ; ", " ) + "." ; "" ; @Unique( @Word( FormFieldListValuesList ; cFromRawValueSeparator ; 2 ) ) ) );  @Do( EditField := EditField;   FromRawValue := "" )  ); REM { With the Edit combo there will be a list of standard seperators to choose from.}; Separator := @If( DataType = ("Implode":"Explode" ) ;  @Prompt( [OkCancelEditCombo] ; cPromptTitle ; "Enter or select the " + @If( DataType = "Implode" ; "separator" ; "separators" ) + ":"  ; "" ; @Unique( @If( FormFieldListValuesList = "" ; cStandardSeparators  ;  FormFieldListValuesList : cStandardSeparators ) ) );  cArraySeparator ); REM {Determine the string to search for}; ExtractValue :@If( DataType = cTextExtractList ;  @Prompt( [OkCancelEditCombo] ; cPromptTitle ; "Enter or select the search string or string length:" ; @Subset( FormFieldListValuesList ; 1 ) ; @Unique( FormFieldListValuesList ) );  "" ); REM {Based on what type of data is being entered different prompts will happen if any at all.}; RawValue := @If(  @Contains( DataType ; "Name Multi Value" ) ; @PickList( [Name] );  @Contains( DataType ; "Name" ) ; @PickList( [Name] : [Single] );  DataType = ( cNoPromptList ) ; "" ;  @Contains( DataType ; "Multi Value" ) ; @Prompt( [OkCancelEditCombo] ; EditFieldPromptTitle; "Enter or select the new desired value for: " + @Implode( EditField ; ", " ) + "." + cPromptNewLineTwo + "Seperated with ; for each value." ; OriginalValue ; @Unique( OriginalValue : FormFieldListValuesList ) ) ;  @Contains( DataType ; "+ Append Values" ) ; @Prompt( [OkCancelEditCombo] ; EditFieldPromptTitle; "Enter or select values to append: " + @Implode( EditField ; ", " ) + "." + cPromptNewLineTwo + "Seperated with ; for each value." ; "" ; @Unique( FormFieldListValuesList ) ) ;  DataType = ("Replace Substring":"Replace" ) ; @Prompt( [OkCancelEditCombo] ; EditFieldPromptTitle ; "Enter or select the text to repalce with in: " + EditField + "." ; "" ; @Unique( @Word( FormFieldListValuesList ; cFromRawValueSeparator ; 1 ) ) ) ;  DataType = "Formula" ; @Do( @DoWhile(   OriginalValue := @Prompt( [OkCancelEditCombo] ; EditFieldPromptTitle ; "Enter or select the new desired formula for: " + EditField + "." ; OriginalValue ; @Unique( OriginalValue : FormFieldListValuesList ) );   tempReturnCheck := @CheckFormulaSyntax( OriginalValue );   @If( tempReturnCheck != "1"; @Prompt( [Ok] ; "Invalid Formula - " + EditFieldPromptTitle ;    "Invalid Formula entered: " +    cPromptNewLineTwo + cPromptTab + "Error: " + cPromptTab + cPromptTab + @Text( tempReturnCheck ) +    cPromptNewLineOne + cPromptTab + "Formula: " + cPromptTab +  cPromptTab + OriginalValue ) ; "" );  tempReturnCheck != "1" );  OriginalValue );  @Prompt( [OkCancelEditCombo] ; EditFieldPromptTitle ; "Enter or select the new desired value for: " + EditField + "." ; OriginalValue  ; @Unique( OriginalValue : FormFieldListValuesList ) )  ); REM {Store Field in Profile doc}; @SetProfileField( cProfileName ; cEditLastField ; @Unique( @Trim( FieldList : ( Form + cEditLastSeparator + EditField[1] ) ) ); @UserName ); REM {Store Data Type of Field in Profile doc}; @SetProfileField( cProfileName ; cEditLastFieldDataType ;  @Unique( @Trim( FormFieldList : ( Form + EditField[1] + cEditLastSeparator + DataType + cEditLastSeparator +   @ReplaceSubstring(    @If( DataType = "Formula" ; RawValue ; FormFieldListFormulaCode ) ;    ";" ; cSemicolonReplace ) ) ) ) ;  @UserName ); REM {Store Data Value of Field in Profile doc}; @SetProfileField( cProfileName ; cEditLastFieldDataTypeValue ;  @Unique( @Trim( FormFieldListDataTypeValues : ( Form + EditField[1] + DataType + cEditLastSeparator +   @Implode(    @Subset(     @Unique(     @ReplaceSubstring(      @If( DataType = ("Implode":"Explode" ) ; Separator ;       DataType = cTextExtractList ; ExtractValue ;       DataType = ( "Replace Substring":"Replace" ) ; RawValue + cFromRawValueSeparator + FromRawValue ;       RawValue ) : FormFieldListValuesList  ;      ";" ; cSemicolonReplace ) ) ;     cFieldHistoryValues );    cValueListSeparator ) ) ) ) ;  @UserName );REM {If multi docs selected, only process those checked ... an unchecked doc cannot be NavNextSelected}; @Command([NavNextSelected]); @UpdateFormulaContext; REM {Store all Note IDs before manipulation in case field modifications cause categorized views or sorted columns to reorganize}; NoteIDList :@Text( @NoteID ); ErrorNoteIDList := ""; @Command([NavNextSelected]); @UpdateFormulaContext; REM {Start Looping Selected documents to gather all the documents that need to be updated.}; @While( ( @Left( NoteIDList ; cNoteEntryLength ) != ( @Text( @NoteID + cArraySeparator ) ) ) & ( @Length( NoteIDList ) < cMaxSearchForSelectedDocs ) ;  NoteIDList := NoteIDList + cArraySeparator + @Text( @NoteID );  NoteIDList := @ReplaceSubstring( NoteIDList ; cCategoryNoteID + cArraySeparator ; "" );  @Command([NavNextSelected]);  @UpdateFormulaContext ); REM {Remove all category Note IDs}; NoteIDList :@ReplaceSubstring( NoteIDList ; cCategoryNoteID ; "" ); REM {Remove all duplicate Note IDs}; NoteIDList :@Unique( @Explode( NoteIDList ; cArraySeparator ; @False ) ); @StatusBar( "Found " + @Text( @Elements( NoteIDList ) ) + " documents." ); NotNoteIDList := ""; REM {Determine if the document should be updated.}; tmpPrompt := @Implode( "The following information will be used to update the " + @Text( @Elements( NoteIDList ) ) + " document" + @If( @Elements( NoteIDList ) > 1 ; "s" ; "" ) + "." + cPromptTab + cPromptTab +  cPromptNewLineTwo + cPromptTab + "Field:" + cPromptTab + cPromptTab + EditField +  cPromptNewLineOne + cPromptTab + "Data type/action: " + cPromptTab + DataType +  cPromptNewLineOne + cPromptTab +   @If(  DataType = ("Implode":"Explode" ) ; "Separator:  " + cPromptTab + Separator ;     DataType = ("Text Left":"Text Left Back":"Text Right":"Text Right Back" ) ; "Search string:  " + cPromptTab + ExtractValue ;     DataType = ("Replace Substring":"Replace" ) ; "Search string:  " + cPromptTab + FromRawValue + cPromptNewLineOne + cPromptTab + "Replace string:  " + cPromptTab + RawValue ;     DataType = cNoPromptList;     "" ;     "Value:  " + cPromptTab + cPromptTab + @Text( RawValue ) ) +  cPromptNewLineTwo + "Would you like to continue?" ); @If( cEnableConfirmation ;  @Do(    @StatusBar( @Explode( tmpPrompt ; cPromptNewLineOne ; @True ) );   @If( @Prompt( [YesNo]; EditFieldPromptTitle ;    tmpPrompt );    "" ; @Return ( "" ) ) );  "" ); REM {Loop through selected docs taking each NoteIDList out of the list as it is processed}; DocUpdateCount := 0; DocNavigationCount := 0; @While( DocUpdateCount < @Elements( NoteIDList ) ;  @If( @TextToNumber( @Text( @DocumentUniqueID ) ) != 0 ;   @Do(    NoteIDList := @Replace( NoteIDList ; @NoteID ; "" ) ;    NotNoteIDList := NotNoteIDList : @NoteID;    @For( ef := 1; ef <= @Elements( EditField ); ef := ef + 1;     formulaResult := @Eval( DataTypeAction ); REMark := " **REM** The values entered above will be applied to all selected doc. If data conversion doesn't work then don't set field.";     @If( @IsError( formulaResult );      @Do(       tmpPrompt := "Error with NoteID of " + @NoteID + ". Continue?" + cPromptTab +       cPromptNewLineOne + cPromptTab + "Error: " + cPromptTab + cPromptTab + @Text( FormulaResult ) +       cPromptNewLineOne + cPromptTab + "Formula: " + cPromptTab +  cPromptTab + DataTypeAction +       cPromptNewLineOne + cPromptTab + @If( @Contains( DataTypeAction ; "EditField[ef]" ) ; "EditField[ef]:" ; "Field:" + cPromptTab ) + cPromptTab + EditField[ef] +       cPromptNewLineOne + cPromptTab + "Data type/action: " + cPromptTab + DataType +       cPromptNewLineOne + cPromptTab +       @If(  DataType = ("Replace Substring":"Replace" ) ; "FromRawValue:  " + cPromptTab + @Text( FromRawValue )+ cPromptNewLineOne + cPromptTab + "RawValue:  " + cPromptTab + @Text( RawValue ) ;         DataType = cNoPromptList;         "" ;         "RawValue:  " + cPromptTab + @Text( RawValue ) );      @StatusBar( @Explode( tmpPrompt ; cPromptNewLineOne ; @True ) );      @If( @Prompt( [YesNo] ;"Error - " + EditFieldPromptTitle ; tmpPrompt ) ;        ErrorNoteIDList := ErrorNoteIDList+ cArraySeparator + @Text( @NoteID );       @Return( @If( @Eval( cErrorCheckCode ) != "" ;        @StatusBar( @Explode( @Eval( cErrorInformation ) ; cPromptNewLineOne ; @True ) ):        @Prompt( [Ok] ; "Unable to Update - " + EditFieldPromptTitle ; @Eval( cErrorInformation ) );       "" ) ) ) );     @SetField( EditField[ef] ; formulaResult )     )    );    @If( DocNavigationCount > cMaxUpdatedDocuments ;      NoteIDList := "";     @Do(      DocUpdateCount := DocUpdateCount + 1;      @Command([NavNextSelected]);      @UpdateFormulaContext; REMark := " **REM** If we haven't processed all docs yet but the current doc is not in the NoteIDList list, keep looping ... if cnt exceeds MaxUpdatedDocuments assume infinite loop and stop ";      @If( DocUpdateCount < @Elements( NoteIDList ) & ( !@Member( @NoteID ; NoteIDList ) ) & ( !@Member( @NoteID ; NotNoteIDList) );       @While( (! @Member( @NoteID ; NoteIDList ) & DocNavigationCount < cMaxUpdatedDocuments );        @Command([NavNextSelected]);        @UpdateFormulaContext;        DocNavigationCount := DocNavigationCount + 1);      "")     )    )   );  @Do( @Command([NavNextSelected]);   @UpdateFormulaContext )  ) ); @If( @Implode( @Unique( @Explode( NoteIDList : ErrorNoteIDList ; cArraySeparator ; @False ) ) ) != "" ;  @StatusBar( @Explode( @Eval( cErrorInformation ) ; cPromptNewLineOne ; @True ) ):  @Prompt( [Ok] ; "Unable to Update - " + EditFieldPromptTitle ; @Eval( cErrorInformation ) );  "" ); @StatusBar( "Navigated through " + @Text( DocUpdateCount + DocNavigationCount ) + " documents." ); @StatusBar( "Performed '" + DataType + "' for '" + @Implode( EditField ; ", " ) + "' field" + @If( @Elements( EditField ) > 1; "s " ; " " ) + "on " + @Text( DocUpdateCount ) + " document" + @If( DocUpdateCount > 1 ; "s" ; "" ) + "." ) ]]></content:encoded>
<wfw:commentRss> https://www.mindoo.com/web/blog.nsf/dxcomments/26.04.2022111021KLECS3.htm</wfw:commentRss>
<wfw:comment> https://www.mindoo.com/web/blog.nsf/dx/26.04.2022111021KLECS3.htm?opendocument&comments</wfw:comment>
</item>
<item>
<title>Ralf Petter’s blog about Notes, Eclipse and Expeditor back online</title>
<pubDate>Mon, 20 Dec 2021 14:06:16 +0200</pubDate>
<description>
<![CDATA[
Yesterday I noticed that Ralf Petter's blog "Everything about IT" is not online anymore. Ralf died years ago from cancer and his blog contains invaluable tips around Notes, Eclipse and Expeditor devel ...
]]>
</description>
<link>https://www.mindoo.com/web/blog.nsf/dx/20.12.2021140602KLEHDH.htm</link>
<category></category>
<dc:creator>Karsten Lehmann</dc:creator>
<comments>https://www.mindoo.com/web/blog.nsf/dx/20.12.2021140602KLEHDH.htm?opendocument&comments</comments>
<guid isPermaLink="true">https://www.mindoo.com/web/blog.nsf/dx/20.12.2021140602KLEHDH.htm</guid>
<content:encoded><![CDATA[ Yesterday I noticed that Ralf Petter's blog "Everything about IT" is not online anymore. Ralf died years ago from cancer and his blog contains invaluable tips around Notes, Eclipse and Expeditor development. In June 2017 when I heard about his death, I downloaded all blog articles and kept them on my local disk. Now that the official blog is gone, I uploaded them to our server, added them to the Google index and made them available here: <a href="https://ralfpetter-blog-mirror.mindoo.de/" target=_blank>https://ralfpetter-blog-mirror.mindoo.de</a> Unfortunately I did not create copies of his free tools and they are not on OpenNTF or Github. I could find the ZIP archive with the latest DocumentSpy plugin in the Wayback machine and fixed the download link in this article: <a href="https://ralfpetter-blog-mirror.mindoo.de/www.everythingaboutit.eu/p/install-document-spy.html" target=_blank>https://ralfpetter-blog-mirror.mindoo.de/www.everythingaboutit.eu/p/install-document-spy.html</a> If anybody has a copy of these three tools, please send them to me: <a href="https://ralfpetter-blog-mirror.mindoo.de/www.everythingaboutit.eu/p/install-extension-spy.html" target=_blank>https://ralfpetter-blog-mirror.mindoo.de/www.everythingaboutit.eu/p/install-extension-spy.html</a> <a href="https://ralfpetter-blog-mirror.mindoo.de/www.everythingaboutit.eu/p/install-todoactivator.html" target=_blank>https://ralfpetter-blog-mirror.mindoo.de/www.everythingaboutit.eu/p/install-todoactivator.html</a> <a href="https://ralfpetter-blog-mirror.mindoo.de/www.everythingaboutit.eu/p/install-shortcutbuttonbar-enabler.html" target=_blank>https://ralfpetter-blog-mirror.mindoo.de/www.everythingaboutit.eu/p/install-shortcutbuttonbar-enabler.html</a> ]]></content:encoded>
<wfw:commentRss> https://www.mindoo.com/web/blog.nsf/dxcomments/20.12.2021140602KLEHDH.htm</wfw:commentRss>
<wfw:comment> https://www.mindoo.com/web/blog.nsf/dx/20.12.2021140602KLEHDH.htm?opendocument&comments</wfw:comment>
</item>
<item>
<title>Mindoo CMS on Domino: Some examples</title>
<pubDate>Tue, 27 Jul 2021 07:42:43 +0200</pubDate>
<description>
<![CDATA[
Mindoo CMS is a Domino powered web content management system that we developed as part of a large project for a local print shop to build a web authoring system for the articles of their local newspap ...
]]>
</description>
<link>https://www.mindoo.com/web/blog.nsf/dx/27.07.2021074242KLE8QA.htm</link>
<category></category>
<dc:creator>Karsten Lehmann</dc:creator>
<comments>https://www.mindoo.com/web/blog.nsf/dx/27.07.2021074242KLE8QA.htm?opendocument&comments</comments>
<guid isPermaLink="true">https://www.mindoo.com/web/blog.nsf/dx/27.07.2021074242KLE8QA.htm</guid>
<content:encoded><![CDATA[ Mindoo CMS is a Domino powered web content management system that we developed as part of a large project for a local print shop to build a web authoring system for the articles of their local newspapers with approval workflow, custom spellchecker with dictionary stored in Domino (based on <a href=http://hunspell.github.io/>http://hunspell.github.io/</a>) and various data exports (e.g. responsive UI and EPUB for subscribers, QuarkXPress and Adobe InDesign for printing machines). The CMS does not just display the final articles, it's driving the whole web application to compose and approve articles as well. Here is a list of the main features: <ul> <li>responsive user interface for desktop and mobile browsers </li><li>live editing of websites: as logged in user, just shift-click on any test in the live website and edit it or add content </li><li>full support of the Domino access model, e.g. to built corporate intranets with different layout/content for target groups </li><li>very flexible templating system based on custom <a href=https://handlebarsjs.com/ target=_blank>Handlebars</a> tags </li><li>no developer skills needed for authors </li><li>compose web site pages out of building blocks predefined by the template editor with unrestricted complexity (e.g. add base page layout, sections for text/images, gallery block and gallery images with meta data; data model is 100% defined within the CMS) </li><li>automatic history of all CMS pages, files and templates: compare current state with any previous versions and revert back changed as needed </li><li>implemented/deployed as OSGi plugins on Domino </li><li>extensible to add custom CMS tags via OSGi extension points</li></ul> Here are some references of web sites that we developed and that are powered by Mindoo CMS: <ul> <li><a href=https://www.duerrschnabel.com/web/index.html>https://www.duerrschnabel.com/web/index.html</a> </li><li><a href=https://www.bietigheim.de/web/index.html>https://www.bietigheim.de/web/index.html</a> </li><li><a href="https://www.gms-bietigheim.de/web/index.html">https://www.gms-bietigheim.de/web/index.html</a> </li><li><a href=https://www.durmersheim.de/web/index.html>https://www.durmersheim.de/web/index.html</a> </li><li><a href=https://www.auamrhein.de/web/index.html>https://www.auamrhein.de/web/index.html</a> </li><li><a href="https://www.elchesheim-illingen.de/web/index.html">https://www.elchesheim-illingen.de/web/index.html</a> </li><li><a href=https://www.weilgut.de/web/index>https://www.weilgut.de/web/index</a></li></ul> ]]></content:encoded>
<wfw:commentRss> https://www.mindoo.com/web/blog.nsf/dxcomments/27.07.2021074242KLE8QA.htm</wfw:commentRss>
<wfw:comment> https://www.mindoo.com/web/blog.nsf/dx/27.07.2021074242KLE8QA.htm?opendocument&comments</wfw:comment>
</item>
<item>
<title>News Update from Mindoo Land: Domino JNA / JNX</title>
<pubDate>Mon, 26 Jul 2021 13:15:43 +0200</pubDate>
<description>
<![CDATA[
In a pandemic (in particular with two young kids of 5 and 7 years), times flies by even faster than in regular times, so it's no surprise that this blog has not seen many updates for a very long time. ...
]]>
</description>
<link>https://www.mindoo.com/web/blog.nsf/dx/26.07.2021131539KLEF8D.htm</link>
<category></category>
<dc:creator>Karsten Lehmann</dc:creator>
<comments>https://www.mindoo.com/web/blog.nsf/dx/26.07.2021131539KLEF8D.htm?opendocument&comments</comments>
<guid isPermaLink="true">https://www.mindoo.com/web/blog.nsf/dx/26.07.2021131539KLEF8D.htm</guid>
<content:encoded><![CDATA[ In a pandemic (in particular with two young kids of 5 and 7 years), times flies by even faster than in regular times, so it's no surprise that this blog has not seen many updates for a very long time. Just wanted to let you know that we are still very busy, leveraging and improving the Domino AppDev platform. The biggest project I have been working on in 2020 and so far in 2021 has to do with our <a href="https://github.com/klehmann/domino-jna" target=_blank>Domino JNA</a> codebase. For the project itself, we released 11 new versions since the beginning of 2020. We added functionality that we needed for our own development projects and the project got additional traction because it was used by the HCL Innovation Labs initially for <a href="https://opensource.hcltechsw.com/domino-keep-docs/" target=_blank>Project Keep</a>, now called HCL Domino REST API and in <a href="https://blog.hcltechsw.com/domino/announcing-the-domino-rest-api-beta-program%E2%80%AF%E2%80%AF/" target=_blank>public beta</a> for a few week. After the first few internal Keep versions, the HCL Innovation Labs team decided that having a modern Java API for Domino would not just be relevant for their own projects but for every developer out there and that this should (hopefully) become the new standard for Java development on Domino. That's why we teamed up with <a href=https://frostillic.us/blog target=_blank>Jesse Gallagher</a> to build something even better than Domino JNA - called <a href="https://opensource.hcltechsw.com/domino-keep-docs/howkeepworks/dominojnx/" target=_blank>Domino JNX</a>. Let's call it Domino JNA on steroids. We took the codebase of Domino JNA and built a powerful API that is both easy to use and has even more features than Domino JNA. Some examples: <ul> <li>automatic garbage collection for Domino C handles (based on Java's <a href="https://www.baeldung.com/java-phantom-reference" target=_blank>PhantomReference</a>) </li><li>leverages modern Java language features like <a href="https://www.baeldung.com/java-generics" target=_blank>Generics</a>, <a href=https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html target=_blank>lambda expressions</a>, the <a href="https://www.baeldung.com/java-8-streams" target=_blank>Stream API</a> and <a href="https://www.baeldung.com/java-optional" target=_blank>Optional's</a> </li><li>more APIs, e.g. to read the database design and current efforts to provide write access as well </li><li>JSON serialization support </li><li>extensible, e.g. to store your own objects in Domino documents</li></ul> JNX is the foundation for the HCL Domino REST API which itself is the foundation for other cool projects like the OpenClient initiative that will provide a native EWS/JMAP API for Domino and therefore native access for Microsoft Outlook, the Apple Mail client and others. There are ongoing efforts to give you, the Domino developer community, access to the JNX API (not just as part of the existing public beta release of the Domino REST API). So stay stuned for upcoming announcements! :-) ]]></content:encoded>
<wfw:commentRss> https://www.mindoo.com/web/blog.nsf/dxcomments/26.07.2021131539KLEF8D.htm</wfw:commentRss>
<wfw:comment> https://www.mindoo.com/web/blog.nsf/dx/26.07.2021131539KLEF8D.htm?opendocument&comments</wfw:comment>
</item>
<item>
<title>OpenNTF May 2021 Webinar: recent Mindoo ToDoManager changes for Notes 12</title>
<pubDate>Thu, 20 May 2021 21:10:19 +0200</pubDate>
<description>
<![CDATA[
Today I took part in OpenNTF's May webinar on recent project updates. I presented the results of my efforts to leverage new functionality of the upcoming Notes 12 client to make our Mindoo ToDoManager ...
]]>
</description>
<link>https://www.mindoo.com/web/blog.nsf/dx/20.05.2021211015KLEQGZ.htm</link>
<category></category>
<dc:creator>Karsten Lehmann</dc:creator>
<comments>https://www.mindoo.com/web/blog.nsf/dx/20.05.2021211015KLEQGZ.htm?opendocument&comments</comments>
<guid isPermaLink="true">https://www.mindoo.com/web/blog.nsf/dx/20.05.2021211015KLEQGZ.htm</guid>
<content:encoded><![CDATA[ Today I took part in OpenNTF's <a href="https://openntf.org/main.nsf/blog.xsp?permaLink=JGAR-C2ZLMR" target=_blank>May webinar on recent project updates</a>. I presented the results of my efforts to leverage new functionality of the upcoming Notes 12 client to make our <a href="https://openntf.org/main.nsf/project.xsp?r=project/Mindoo%20TodoManager" target=_blank>Mindoo ToDoManager application</a> more responsive and adaptable to the available screen real estate. The application now autodetects the size of the Notes/Nomad client window on startup and picks the best application layout: you either see all four quadrants <div align=center><img alt="Image:OpenNTF May 2021 Webinar: recent Mindoo ToDoManager changes for Notes 12" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/20.05.2021211015KLEQGZ.htm/content/M2?OpenElement" /></div> or the mobile optimized narrow layout with a single quadrant at a time: <div align=center><img alt="Image:OpenNTF May 2021 Webinar: recent Mindoo ToDoManager changes for Notes 12" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/20.05.2021211015KLEQGZ.htm/content/M3?OpenElement" /></div> Notes 12 provides two new @formulas <tt>@ResolutionWidth</tt> / <tt>@ResolutionHeight</tt> to read the dimension of the current UI form or UI view. And you get a new form/view event "onsize" that gets triggered on window resize. Enter the formula <tt>@Command([RelayoutWindow])</tt> here and your layout gets recomputed when the window is resized by the user, e.g. hide/when or subform formulas that depend on the form dimension might produce a different output. To be honest I was fighting a bit to get this new functionality to work reliable in the latest R12 beta 3 client. The TodoManager proves that responsive layouts for Notes applications are indeed possible. But I reported a bunch of issues in the beta program that hopefully get fixed until the final R12 release to make this easier to use. E.g. my Designer installation does not save the code that I enter in the "onsize" event. And the resolution formulas often seem to be computed too early, e.g. you still get UI view dimensions back after you have opened a doc in a view. While I was updating the OpenNTF project download with the latest version, I also added some documentation and references on the project summary page. I highly recommend watching the two videos that are linked in the text if you haven't done already. They were recorded in 2007, but are still very inspiring. Anyway, I hope you like the new version. Here is the updated project description: Four Quadrant Theory The TodoManager is based on Covey's Four Quadrant theory that is described in this article: <a href="https://appfluence.com/productivity/time-management-strategies-for-busy-people-using-the-4-quadrant-method/" target=_blank>Time management strategies for busy people using the 4-quadrant method</a> It provides a graphical concept of todo management where you place your todos in a 2x2matrix of four quadrants. By doing that you decide whether your topic is important/ not important and due soon/ not due soon. Following the order of the quadrants is key to organizing your life: Start with quadrant 1 (important/ due soon), continue with 2 (important/ not due soon), 3 (not important/ due soon) and end with todos in quadrant 4 (not important/ not due soon). In each quadrant, pick the ugliest task first. I got to know Covey's theory when I was watching <a href="https://www.youtube.com/watch?v=ji5_MqicxSo" target=_blank>Randy Pausch's Last Lecture</a> and his <a href="https://www.youtube.com/watch?v=oTugjssqOT0" target=_blank>Lecture about Time Management</a>. Both recordings are highly recommended to put your daily struggles and project deadlines into perspective: Carnegie Mellon Professor Randy Pausch (Oct. 23, 1960 - July 25, 2008) gave his last lecture at the university Sept. 18, 2007, before a packed McConomy Auditorium, months before he died from pancreatic cancer and reflects on how much he achieved his childhood dreams. Usage Use the â\x80\x9c+â\x80\x9d icon to create new todos and decide in which quadrant (=Notes folder) it should be moved on first save. Use drag and drop or context menu actions to move your tasks between quadrants (numbers â\x80\x9c1â\x80\x9d, â\x80\x9c2â\x80\x9d, â\x80\x9c3â\x80\x9d, â\x80\x9c4â\x80\x9d are drop targets) or into the recycle bin. Responsive UI The TodoManager application has a responsive user interface that works on desktop Notes Client, HCL Nomad clients on tablets/phones and even the new Nomad web client. By providing two different application layouts it adapts to the available screen real estate: one layout that displays all 4 quadrants at once and a second one where you only see a single quadrant and have hotspots to change quadrants in the top navigation. On Notes 12 we leverage new @formulas to query the current window dimension while still being backward compatible with older Notes Client versions. That means that even in the desktop Notes Client you get a different user experience when the client window width is not very wide. The window size is detected on application startup. Installation Just copy the provided application template to your server, sign it and create a new database instance. Then give yourself editor access in the ACL and all others no access. There are currently no background agents to enable. ]]></content:encoded>
<wfw:commentRss> https://www.mindoo.com/web/blog.nsf/dxcomments/20.05.2021211015KLEQGZ.htm</wfw:commentRss>
<wfw:comment> https://www.mindoo.com/web/blog.nsf/dx/20.05.2021211015KLEQGZ.htm?opendocument&comments</wfw:comment>
</item>
<item>
<title>Mindoo TodoManager on OpenNTF</title>
<pubDate>Sat, 14 Dec 2019 09:30:14 +0200</pubDate>
<description>
<![CDATA[
I created a small sample application for the HCL Nomad Client on the iPad and iPhone. It's a TodoManager that uses the 4 Quadrant time management method to structure the Todos. The application is now ...
]]>
</description>
<link>https://www.mindoo.com/web/blog.nsf/dx/14.12.2019093007KLEBYY.htm</link>
<category>Free Tools</category>
<dc:creator>Karsten Lehmann</dc:creator>
<comments>https://www.mindoo.com/web/blog.nsf/dx/14.12.2019093007KLEBYY.htm?opendocument&comments</comments>
<guid isPermaLink="true">https://www.mindoo.com/web/blog.nsf/dx/14.12.2019093007KLEBYY.htm</guid>
<content:encoded><![CDATA[ I created a small sample application for the HCL Nomad Client on the iPad and iPhone. It's a TodoManager that uses the 4 Quadrant time management method to structure the Todos. The application is now available for free on OpenNTF: <a href="https://openntf.org/main.nsf/project.xsp?r=project/Mindoo%20TodoManager" target=_blank>Mindoo TodoManager</a> In the desktop Notes Client, to dos can be moved between the quadrants and to the recycle bin via drag and drop ("1" - "4" and the recycle bin icon are drop targets). In HCL Nomad, just do a long click on a document to see the available options. The UI is responsive and should fit on all devices. <img alt="Image:Mindoo TodoManager on OpenNTF" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/14.12.2019093007KLEBYY.htm/content/M2?OpenElement" /> <img alt="Image:Mindoo TodoManager on OpenNTF" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/14.12.2019093007KLEBYY.htm/content/M3?OpenElement" /> <img alt="Image:Mindoo TodoManager on OpenNTF" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/14.12.2019093007KLEBYY.htm/content/M4?OpenElement" /> <img alt="Image:Mindoo TodoManager on OpenNTF" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/14.12.2019093007KLEBYY.htm/content/M5?OpenElement" /> <img alt="Image:Mindoo TodoManager on OpenNTF" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/14.12.2019093007KLEBYY.htm/content/M6?OpenElement" /> ]]></content:encoded>
<wfw:commentRss> https://www.mindoo.com/web/blog.nsf/dxcomments/14.12.2019093007KLEBYY.htm</wfw:commentRss>
<wfw:comment> https://www.mindoo.com/web/blog.nsf/dx/14.12.2019093007KLEBYY.htm?opendocument&comments</wfw:comment>
</item>
<item>
<title>Documentation for @GetMachineInfo</title>
<pubDate>Wed, 4 Dec 2019 14:47:07 +0200</pubDate>
<description>
<![CDATA[
Since there currently is no place to find this information on HCL websites in Google, I am adding it here: @GetMachineInfo new in 8.5.3 New @Function to support Machine Specific Policy Settings Sy ...
]]>
</description>
<link>https://www.mindoo.com/web/blog.nsf/dx/04.12.2019144707KLEJ72.htm</link>
<category></category>
<dc:creator>Karsten Lehmann</dc:creator>
<comments>https://www.mindoo.com/web/blog.nsf/dx/04.12.2019144707KLEJ72.htm?opendocument&comments</comments>
<guid isPermaLink="true">https://www.mindoo.com/web/blog.nsf/dx/04.12.2019144707KLEJ72.htm</guid>
<content:encoded><![CDATA[ Since there currently is no place to find this information on HCL websites in Google, I am adding it here: @GetMachineInfo new in 8.5.3 New @Function to support Machine Specific Policy Settings Syntax: <code>@GetMachineInfo( [Keyword]; "Needed for some Keywords string" )</code> Keywords: IsLaptop - boolean return - True if machine is a laptop, otherwise false IsDesktop - boolean return - True if machine is NOT a laptop, otherwise false IsSingleLogOn - boolean return - True if machine has Notes client installed with "single sign on", otherwise false IsMultiUser - boolean return - True if machine has Notes client installed as Multi-User, otherwise false HasDesigner - boolean return - True if machine has Designer client installed, otherwise false HasAdmin - boolean return - True if machine has Admin client installed, otherwise false IsStandard - boolean return - True if machine is running Standard Notes client, otherwise false MachineName - string return - Name of the machine boolean return        True if MachineName string after keyword matches this machine's MachineName, otherwise false Memory - number return - Total amount of memory (RAM) DiskSpace - number return - Amount of free disk space Note: With this keyword, you can add a second parameter for the drive to scan for free space. If this parameter is not passed to the function, free space for the first (logical) drive - for example, drive C on Windows system - is displayed. Example: <code>@GetMachineInfo([DiskSpace];"d:")</code> EnvVariable - string return - Requires string of the variable name in Notes.ini to read, and returns the value of that ini variable or "" (null string) if not found SysEnvVariable - string return - Requires string of the variable name in system environment to read, and returns the value of that variable or "" (null string) if not found IP - string/list return - String representation of the IP address(es) in the form XXX.XXX.XXX.XXX , otherwise "" (null string) if not available boolean return        True if pattern IP string after keyword matches this machine's IP address, otherwise false MAC - string/list return - String representation of the MAC address(es) in the form XX:XX:XX:XX:XX:XX , otherwise "" (null string) if not available boolean return        True if MAC string after keyword matches this machine's MAC address, otherwise false ]]></content:encoded>
<wfw:commentRss> https://www.mindoo.com/web/blog.nsf/dxcomments/04.12.2019144707KLEJ72.htm</wfw:commentRss>
<wfw:comment> https://www.mindoo.com/web/blog.nsf/dx/04.12.2019144707KLEJ72.htm?opendocument&comments</wfw:comment>
</item>
<item>
<title>Configure Eclipse 4.6.x with HCL Notes 10</title>
<pubDate>Mon, 4 Nov 2019 16:06:07 +0200</pubDate>
<description>
<![CDATA[
For years, whenever I needed to configure an Eclipse IDE for IBM Notes plugin development, I used Mikkel Heisterberg's instructions on his blog. Since I currently have a customer requirement to updat ...
]]>
</description>
<link>https://www.mindoo.com/web/blog.nsf/dx/04.11.2019160604KLEKQD.htm</link>
<category>Eclipse</category>
<dc:creator>Karsten Lehmann</dc:creator>
<comments>https://www.mindoo.com/web/blog.nsf/dx/04.11.2019160604KLEKQD.htm?opendocument&comments</comments>
<guid isPermaLink="true">https://www.mindoo.com/web/blog.nsf/dx/04.11.2019160604KLEKQD.htm</guid>
<content:encoded><![CDATA[ For years, whenever I needed to configure an Eclipse IDE for IBM Notes plugin development, I used Mikkel Heisterberg's instructions on his <a href="https://lekkimworld.com/configure-eclipse-4-2-for-notes-9/" target=_blank>blog</a>. Since I currently have a customer requirement to update an existing plugin that we built for them years ago to a newer Java version (1.8), I tried to set up Eclipse 2019-09 with HCL Notes 10.0.1FP2, but failed. The launching Client did not show any file/edit/view menus, probably caused by a ClassCastException I could see in the launch console. I guess the reason is that 9.0.1 FP10 brought a major update for the underlying Eclipse and OSGi platform. So I contacted HCL development and asked for the updated parameters to make this work again and quickly got a response that I would like to share with you. The document links to Eclipse Neon 4.6.3, but it's still working for me in Eclipse 2019-09 (4.13.0). 1. Download Eclipse Neon (4.6.3) or later from link below: <a href="http://www.eclipse.org/downloads/download.php?file=/technology/epp/downloads/release/neon/3/eclipse-committers-neon-3-win32-x86_64.zip" target=_blank>http://www.eclipse.org/downloads/download.php?file=/technology/epp/downloads/release/neon/3/eclipse-committers-neon-3-win32-x86_64.zip</a> 2. Get the latest V10 build 3. Go to Windows => Preferences => Java => Installed JREs <ul> <li>Add => Standard VM => </li><li>JRE home: <code>[Notes Install path]\jvm</code>, e.g. <code>C:\Program Files (x86)\IBM\Notes\jvm</code> </li><li>JRE name: â\x80\x9cNotes JREâ\x80\x9d </li><li>Select the JRE to point to this and Apply</li></ul> 4. Go to Windows => Preferences => Plug-in Development => Target Platform <ul> <li>Add => default => Target Content </li><li>Name: â\x80\x9cNotes Targetâ\x80\x9d</li></ul> 4a. In Locations Tab: <ul> <li>Add => Directory => Location => <code>[Notes Install path]\framework\rcp\eclipse\plugins</code> </li><li>Add => Directory => Location => <code>[Notes Install path]\framework\shared\eclipse\plugins</code> </li><li>Finish </li><li>Select the Target platform to point to â\x80\x9cNotes Targetâ\x80\x9d and Apply</li></ul> 4 b. In Environment Tab: Please select following settings: <ul> <li>Operating System: win32 </li><li>Windowing System: win32 </li><li>Architecture: x86 </li><li>Locale: en_US - English (United States)</li></ul> 5. Go to Windows => Preferences => Run/Debug => String Substitution New => Add 2 strings (replace "xxxx" with the right plugin version!) 5a. Name: rcp_home Value: <code>[Notes Install path]\framework</code> 5b. Name: rcp_base Value: <code>[Notes Install path]\framework\rcp\eclipse\plugins\com.ibm.rcp.base_10.0.0.xxxx</code> OK Close this Preferences Window 6. Put the following file inside the below plugin: <code>[Notes Install path]\framework\rcp\eclipse\plugins\com.ibm.rcp.base_10.0.0.xxxx</code> <a href="https://www.mindoo.com/web/blog.nsf/dx/rcp.security.properties/$file/rcp.security.properties" target="_blank" title="rcp.security.properties">rcp.security.properties</a> 7. Open Debug Configurations in the â\x80\x98Debug Perspectiveâ\x80\x99 => Eclipse Configuration => New 7a. In the Main tab: Name: NotesDebug Program to Run =>  Run a product => com.ibm.notes.branding.notes Java Runtime Environment => Runtime JRE => Select â\x80\x9cNotes JREâ\x80\x9d i.e. the one we added in step 3 7b. In the Arguments tab: Program Arguments: <code>-clean -console -debug -log -personality com.ibm.rcp.platform.personality -config notes</code> VM Arguments: <code>-Xquickstart -Xss384k -Xshareclasses -Drcp_home="${rcp_home}" -Drcp.install.config=user -Dosgi.install.area="${rcp_home}\eclipse" -Disa.ignoreESR=true -Dcom.ibm.pvc.osgiagent.core.logfileloc="${rcp_home}\rcp" -Dcom.ibm.pvc.webcontainer.port=0 -Declipse.pluginCustomization="${rcp_home}\rcp\plugin_customization.ini" -Djava.security.properties="${rcp_base}\rcp.security.properties" -Declipse.registry.nulltoken=true -Djava.protocol.handler.pkgs=com.ibm.net.ssl.www.protocol -Djava.util.logging.config.class=com.ibm.rcp.core.internal.logger.boot.LoggerConfig -Dosgi.hook.configurators.exclude=org.eclipse.core.runtime.internal.adaptor.EclipseLogHook -Dosgi.framework.extensions=com.ibm.rcp.core.logger.frameworkhook,com.ibm.rds,com.ibm.cds -Xbootclasspath/a:${rcp_base}\rcpbootcp.jar;<br-Xdump:system:events=user</code> 8. Apply => Debug â\x80\x93 This will launch your Notes in Debug mode. Ensure that whenever you launch the Notes from Eclipse, there should be no other instance of Notes already running. If so, please close Notes and then launch from Eclipse to debug. ]]></content:encoded>
<wfw:commentRss> https://www.mindoo.com/web/blog.nsf/dxcomments/04.11.2019160604KLEKQD.htm</wfw:commentRss>
<wfw:comment> https://www.mindoo.com/web/blog.nsf/dx/04.11.2019160604KLEKQD.htm?opendocument&comments</wfw:comment>
</item>
<item>
<title>New Domino JNA version available with LOTS of new features</title>
<pubDate>Thu, 19 Sep 2019 17:23:43 +0200</pubDate>
<description>
<![CDATA[
It's been a long time since the last release of our Domino JNA project. Version 0.9.21 is now available for download as XPages Extensibility Plugin and on its way to Maven Central (takes a few hours t ...
]]>
</description>
<link>https://www.mindoo.com/web/blog.nsf/dx/19092019172343KLEL3E.htm</link>
<category>Domino C API</category>
<dc:creator>Karsten Lehmann</dc:creator>
<comments>https://www.mindoo.com/web/blog.nsf/dx/19092019172343KLEL3E.htm?opendocument&comments</comments>
<guid isPermaLink="true">https://www.mindoo.com/web/blog.nsf/dx/19092019172343KLEL3E.htm</guid>
<content:encoded><![CDATA[ It's been a long time since the last release of our Domino JNA project. Version 0.9.21 is now available for <a href="https://github.com/klehmann/domino-jna/releases/tag/0.9.21" target=_blank>download as XPages Extensibility Plugin</a> and on its way to <a href="https://mvnrepository.com/artifact/com.mindoo.domino/domino-jna" target=_blank>Maven Central</a> (takes a few hours to appear). Here are a some highlights of the new version: <ul><li>New method to read item definition table of a database</li><li>Added function to get the template db path by the template name</li><li>Support for profile note reading and writing</li><li>Added API to export mails as EML files on client and server</li><li>Added API to read client and server statistics</li><li>Tested in Notes/Domino 11 beta 1</li><li>Added method to harvest DB design for DQL speedup</li><li>DQL query builder updated for new Domino 11 "contains" terms (FT search)</li><li>New method to send server console commands</li><li>Improved richtext to HTML conversion sample to extract files as well</li><li>Added convenience functions NotesDatabase.toUnid / toNoteId</li><li>Added NotesDatabase.getAllCollections() to read infos about all views</li><li>NotesTimeDate.toString method with date/time/timezone formatting options</li><li>Added NotesIntlFormat argument to NotesTimeDate.fromString</li><li>Added setter to change timezone of NotesTimeDate</li><li>New methods to read ACL entries and all ACL roles</li><li>New methods in NotesCollection to read view design properties, e.g. .isConflict(), .isCollapsed(), isGotoTopOnOpen() etc.</li><li>Added method to check if $file item belongs to a TYPE_MIME_PART item</li><li>Added method NotesItem.copyToNote() with parameter to rename the item</li><li>Added check method to large summary buffer support on DB</li><li>Added checks for ERR 1028 when openings docs to return null if not found</li><li>Improved reading of data below view categories</li><li>Added method to convert RFC822 items to native Domino format</li><li>NotesDatabase.openMailDatabase(), hasFullAccess() and runWithDbLock()</li><li>Changed flag to find view in design, did not find all available views</li><li>Flags to update note without triggering replication (used by replicator)</li><li>Added experimental code to set sequence number and time</li><li>Added more HTML conversion options</li><li>More FTSearch options for NotesDatabase searches (e.g. get result sorted by created/modified/score)</li><li>Additional methods to write Notes.ini variables (e.g. OSGI_HTTP_DYNAMIC_BUNDLES)</li><li>Added getter to read TIMEDATE value from Notes.ini with testcase</li><li>NotesCollection column title/name no longer converted to lowercase</li><li>Removed ICU4J dependency, now using undocumented method OSTranslate32 to translate between LMBCS and Java strings with support for long texts (length > WORD size that OSTranslate supports)</li><li>Performance optimizations, fixed memory handle leaks</li></ul> <ul> <li></li></ul> ]]></content:encoded>
<wfw:commentRss> https://www.mindoo.com/web/blog.nsf/dxcomments/19092019172343KLEL3E.htm</wfw:commentRss>
<wfw:comment> https://www.mindoo.com/web/blog.nsf/dx/19092019172343KLEL3E.htm?opendocument&comments</wfw:comment>
</item>
</channel></rss>

If you would like to create a banner that links to this page (i.e. this validation result), do the following:

Download the "valid RSS" banner.
Upload the image to your own server. (This step is important. Please do not link directly to the image on this server.)
Add this HTML to your page (change the image src attribute if necessary):

<a href="http://www.feedvalidator.org/check.cgi?url=http%3A//www.mindoo.com/web/blog.nsf/feed.rss"><img src="valid-rss-rogers.png" alt="[Valid RSS]" title="Validate my RSS feed" /></a>

If you would like to create a text link instead, here is the URL you can use:

http://www.feedvalidator.org/check.cgi?url=http%3A//www.mindoo.com/web/blog.nsf/feed.rss

Home · About · News · Docs · Terms