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 228, column 10: category should not be blank [help]

<category></category>
          ^

line 355, 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>Tue, 6 Mar 2018 16:19:03 +0200</lastBuildDate>
<item>
<title>Display all allowed readers of documents in a view column</title>
<pubDate>Tue, 6 Mar 2018 16:19:03 +0200</pubDate>
<description>
<![CDATA[
By setting the programmatic column name and formula value of a view column to "$C1$", the column automatically displays the content of all reader items in the document. If there are any readers, the ...
]]>
</description>
<link>https://www.mindoo.com/web/blog.nsf/dx/06.03.2018161900KLEKYG.htm</link>
<category>Notesdev</category>
<dc:creator>Karsten Lehmann</dc:creator>
<comments>https://www.mindoo.com/web/blog.nsf/dx/06.03.2018161900KLEKYG.htm?opendocument&comments</comments>
<guid isPermaLink="true">https://www.mindoo.com/web/blog.nsf/dx/06.03.2018161900KLEKYG.htm</guid>
<content:encoded><![CDATA[ By setting the programmatic column name and formula value of a view column to "$C1$", the column automatically displays the content of all reader items in the document. If there are any readers, the column also container the author item values, since these are also allowed to see read-restricted documents. <img alt="Image:Display all allowed readers of documents in a view column" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/06.03.2018161900KLEKYG.htm/content/M2?OpenElement" /> <img alt="Image:Display all allowed readers of documents in a view column" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/06.03.2018161900KLEKYG.htm/content/M3?OpenElement" /> "$C1$" is a special column value that the NIF indexer sends to the NSF Search command in the C API to let it compute read access. This information is stored in the view index and compared to the current user's NAMES_LIST (list of name wildcards, groups and roles) on view access (case-insensitive). To use this in your own C code, some more work is required. You don't pass a compiled selection formula to NSFSearch, but a view formula, which is the selection formula merged with all view column formulas (NSFFormulaSummaryItem). Of course this is not documented anywhere in the C API, that such a view formula can be passed to NSFSearch, same for the special value "$C1$". ;-) In addition, you need to pass the constant <code>SEARCH_NOITEMNAMES 0x0020</code> to the NSF Search, which tells it to not return the whole note summary buffer for each search match (ITEM_TABLE structure), but just the values specified as columns in the view formula in their order, which makes the search a lot faster. Too difficult? No problem. <a href="https://github.com/klehmann/domino-jna" target=_blank>Domino JNA</a> to the rescue. This NSF search is the base of our incremental Domino data sync. So effectively, we do (almost) index Domino data like NIF, but with different target system. If not all information is available via summary items, the sync code can provide access to the document as well. There's code to sync Domino data with the <a href="https://github.com/klehmann/domino-jna/tree/master/domino-jna-indexer-cqengine" target=_blank>CQEngine indexer</a> and an <a href="https://github.com/klehmann/domino-jna/tree/master/domino-jna-indexer-sqlite" target=_blank>SQLite database</a>. The two projects contain testcases to demonstrate the syntax. ]]></content:encoded>
<wfw:commentRss> https://www.mindoo.com/web/blog.nsf/dxcomments/06.03.2018161900KLEKYG.htm</wfw:commentRss>
<wfw:comment> https://www.mindoo.com/web/blog.nsf/dx/06.03.2018161900KLEKYG.htm?opendocument&comments</wfw:comment>
</item>
<item>
<title>Major rewrite of Domino JNA for improved performance, now with incremental indexing of Domino data</title>
<pubDate>Mon, 8 Jan 2018 11:14:30 +0200</pubDate>
<description>
<![CDATA[
I spend a few days during the Christmas holidays and first week of January to work on our Domino JNA project. The result is version 0.9.11, which is now on its way to Maven Central and available for d ...
]]>
</description>
<link>https://www.mindoo.com/web/blog.nsf/dx/08.01.2018111425KLEE24.htm</link>
<category>Domino C API</category>
<dc:creator>Karsten Lehmann</dc:creator>
<comments>https://www.mindoo.com/web/blog.nsf/dx/08.01.2018111425KLEE24.htm?opendocument&comments</comments>
<guid isPermaLink="true">https://www.mindoo.com/web/blog.nsf/dx/08.01.2018111425KLEE24.htm</guid>
<content:encoded><![CDATA[ I spend a few days during the Christmas holidays and first week of January to work on our <a href="https://github.com/klehmann/domino-jna" target=_blank>Domino JNA</a> project. The result is version 0.9.11, which is now on its way to <a href="https://mvnrepository.com/artifact/com.mindoo.domino/domino-jna" target=_blank>Maven Central</a> and available for <a href="https://github.com/klehmann/domino-jna/releases" target=_blank>download as an OSGi plugin</a> for XPages developers. Here are the three main features that I have been working on: Improved performance The project source code has been completely rewritten to use <a href="https://github.com/java-native-access/jna/blob/master/www/DirectMapping.md" target=_blank>JNA direct mapping</a>. This significantly improves performance in areas with lots of native method invocations like document item access or when adding note ids to ID tables. Other performance work has been done to speed up LMBCS-Java-String conversion and to lazily convert summary buffer values when doing a database search (the old version always converted the whole buffer). Incremental data indexing As I recently wrote on <a href=https://twitter.com/klehmann79 target=_blank>Twitter</a>, I do not know how many code I have written in the past to sync Domino data to external databases or indexers, because they are more powerful doing adhoc-queries than Domino. The good news is that IBM is actively looking into this topic for Domino 10. So here is another approach, this time using C API calls, incrementally searching for database changes filtered by an @-formula and not requiring any lookup views. The key to getting it implemented this way was the discovery that <tt>NSFSearchExtended3</tt>, which I am using to search for formula matches, can not only run incrementally by passing a "since" value and returns all changed notes matching the formula, but also calls the callback for all changed and deleted notes not matching the formula. This way my code knows what to add/update in the external db or index and also knows what to remove if it existed in the index before. To make the algorithm easily reusable, I haven't hard coded a specific sync target. The whole sync process is running against a simple <a href="https://github.com/klehmann/domino-jna/blob/master/domino-jna/src/main/java/com/mindoo/domino/jna/sync/ISyncTarget.java" target=_blank>Java interface</a>. A <a href="https://github.com/klehmann/domino-jna/tree/master/domino-jna-indexer-cqengine" target=_blank>sample project</a> is already available with code that synchronized Domino data with the Java based <a href=https://github.com/npgall/cqengine target=_blank>CQEngine indexer</a>. The project contains a testcase that indexes the fakenames database and makes sure everything is working as expected. My plan is to create more implementations, e.g. for SQLite or Lucene, but no promises :-). The generic sync process handles replication against multiple replicas of the same database (e.g. when replicating with a Domino cluster) and changing the selection formula between syncs, where we do a performance improved comparison what needs to be added to the target and what does not match the new selection formula anymore and gets purged. Better testcases This is far from being finished, but I started reworking the available testcases so that they do not any longer only "work on my machine", because the sample database that is available for download does not contain some newly added lookup views or documents. The plan is to automatically create the sample database with the required structure the first time the test cases are executed, based on a Domino address book template, creating lookup views in code and <a href="https://github.com/klehmann/domino-jna/tree/master/sampledata" target=_blank>50.000 fake person documents</a>. For other changes, here are the release notes posted  on Github: <ul> <li>Complete project rewrite, now using JNA direct mapping to improve native method invocation performance </li><li>other performance improvement: faster LMBCS->Java String conversion, lazy conversion of summary value items in NotesSearch.search(...) </li><li>Improved database search (NotesSearch.search) that now also optionally returns non-matches and deletions when searching incrementally with a "since" date (see callback class com.mindoo.domino.jna.NotesSearch.SearchCallback) </li><li>New generic class com.mindoo.domino.jna.sync.SyncUtil to incrementally read Domino data for indexing and migration purpose </li><li>Sample implementation for SyncUtil that indexes data using CQEngine to index Domino data is available as separate project (to reduce the Domino JNA dependencies to a minimum) </li><li>New methods NotesNote.hasReadersField() and NotesNote.getReadersFields() to get reader fields of a note using an optimized C call </li><li>New methods for NotesDatabase: <ul> </li><li>getTitle() / setTitle(String title) </li><li>getCategories() / setCategories(String cat) </li><li>getTemplateName() / setTemplateName(String name) </li><li>getDesignTemplateName() / setDesignTemplateName(String name) </li><li>refreshDesign(String server)</li></ul> <li>added method DirectoryScanner.scan(String formula) to filter directory entries using Domino formula language </li><li>Bugfixing and package refactoring to hide internal code (struct package moved to com.mindoo.domino.jna.internal) </li><li>Removed the unfinished com.mindoo.domino.jna.queries package; will probably not continue this path, incremental indexing is the way to go</li></ul> ]]></content:encoded>
<wfw:commentRss> https://www.mindoo.com/web/blog.nsf/dxcomments/08.01.2018111425KLEE24.htm</wfw:commentRss>
<wfw:comment> https://www.mindoo.com/web/blog.nsf/dx/08.01.2018111425KLEE24.htm?opendocument&comments</wfw:comment>
</item>
<item>
<title>Bleedyellow.com has a new home</title>
<pubDate>Sat, 11 Nov 2017 12:16:44 +0200</pubDate>
<description>
<![CDATA[
It took some time and the domain transfer is not 100% complete, but bleedyellow.com is on it's way from René Winkelmeyer to Mindoo. Our blog is currently configured to be the default website on ww ...
]]>
</description>
<link>https://www.mindoo.com/web/blog.nsf/dx/11.11.2017121642KLEF92.htm</link>
<category>Mindoo</category>
<dc:creator>Karsten Lehmann</dc:creator>
<comments>https://www.mindoo.com/web/blog.nsf/dx/11.11.2017121642KLEF92.htm?opendocument&comments</comments>
<guid isPermaLink="true">https://www.mindoo.com/web/blog.nsf/dx/11.11.2017121642KLEF92.htm</guid>
<content:encoded><![CDATA[ It took some time and the domain transfer is not 100% complete, but bleedyellow.com is on it's way from René Winkelmeyer to Mindoo. Our blog is currently configured to be the default website on   <div align=center><a href=https://www.bleedyellow.com/ target=_blank>www.bleedyellow.com</a></div> We do not have any plans yet for the domain, but did not want to let it expire. If you have any suggestions, feel free to comment. ]]></content:encoded>
<wfw:commentRss> https://www.mindoo.com/web/blog.nsf/dxcomments/11.11.2017121642KLEF92.htm</wfw:commentRss>
<wfw:comment> https://www.mindoo.com/web/blog.nsf/dx/11.11.2017121642KLEF92.htm?opendocument&comments</wfw:comment>
</item>
<item>
<title>Life sign / Major update for Domino JNA on Github</title>
<pubDate>Fri, 10 Nov 2017 17:25:35 +0200</pubDate>
<description>
<![CDATA[
Wow - I haven't written a blog post in the last 9 months! It's just so much easier to write a Tweet than to produce long articles, when I split the week between three customers and my family with two ...
]]>
</description>
<link>https://www.mindoo.com/web/blog.nsf/dx/10.11.2017172532KLEM9Z.htm</link>
<category>Domino C API</category>
<dc:creator>Karsten Lehmann</dc:creator>
<comments>https://www.mindoo.com/web/blog.nsf/dx/10.11.2017172532KLEM9Z.htm?opendocument&comments</comments>
<guid isPermaLink="true">https://www.mindoo.com/web/blog.nsf/dx/10.11.2017172532KLEM9Z.htm</guid>
<content:encoded><![CDATA[ Wow - I haven't written a blog post in the last 9 months! It's just so much easier to write a <a href=https://twitter.com/klehmann79 target=_blank>Tweet</a> than to produce long articles, when I split the week between three customers and my family with two children. Just wanted to let you know that we are alive and kicking and still doing very much Domino related work! :-) Technologies have as always shifted a bit. Most of the time we create pure JavaEE projects now for our customer web apps, developed in Eclipse and not Domino Designer (ok, using it to create lookup views, still working on that part ;-) ). A Maven build then collects all moving parts and generates an OSGi update site that can be deployed on the Domino server. So our NSFs contain no code and no further design elements except those lookup views. For the frontend, we are mostly using a mix of Bootstrap, React, jQuery and a lot of open source widgets and libraries that we find on the Internet. Some other areas of interest include using ES5/ES6 JavaScript features like async/await and as always exploring what other database systems have to offer. The backend of our apps is more and more powered by our <a href="https://github.com/klehmann/domino-jna" target=_blank>Domino JNA</a> project to get the most out of Domino. The project is now used in 7 of our customer web apps and services, of course running on production servers for months. Since my last post in January, a lot of work has been done to make the project more powerful and more robust. I am happy to announce that version 0.9.9 is now available on <a href="https://mvnrepository.com/artifact/com.mindoo.domino/domino-jna/0.9.9" target=_blank>Maven Central</a> and as an <a href="https://github.com/klehmann/domino-jna/releases/tag/0.9.9" target=_blank>XPages Extension Library</a>. Here are some of the new features: <ul> <li>APIs to convert a single richtext item or a whole document to HTML with access to embedded images - NotesNote.convertItemToHtml / NotesNote.convertNoteToHtml() </li><li>APIs to stop long running code, get progress information and replication progress/results - SignalHandlerUtil </li><li>APIs to read/write Notes.ini values - NotesIniUtils </li><li>Utility function to compare Notes names with wildcards (*/Company) - NotesNamingUtils.nameMatchesWildcard() </li><li>Support to pass open flags when opening a database, e.g. for cluster failover - OpenDatabase enum </li><li>Method to replicate a database with options and detailed replication stats - NotesDatabase.replicateWithServer() </li><li>Method NotesNote.setUNID() to change the UNID of a document </li><li>Utility class to get names of cluster members of a Domino server - ServerUtils</li></ul> Performance improvements: <ul> <li>Now reading view column names/sortings/formulas using C API in NotesCollection, not having to reopen the DB/View with legacy API (Notes.jar) anymore </li><li>Improved LMBCS string conversion performance (less copy operations for pure ASCII strings)</li></ul> Breaking changes: <ul> <li>Removed lotus.domino.Session argument from some of the NotesDatabase constructors (not needed anymore) </li><li>Using NoteClass enum instead of noteclass bitmask, e.g. for database searches</li></ul> I'd love to write more about all the features or product some slides and (re-)appear at conferences, but unfortunately time is very limited. So I see what I can do to at least produce more test cases or make the existing ones work. I should have a bit more time now, since there are not many prio 1 topics left on my list that I need to add to the project. :-) ]]></content:encoded>
<wfw:commentRss> https://www.mindoo.com/web/blog.nsf/dxcomments/10.11.2017172532KLEM9Z.htm</wfw:commentRss>
<wfw:comment> https://www.mindoo.com/web/blog.nsf/dx/10.11.2017172532KLEM9Z.htm?opendocument&comments</wfw:comment>
</item>
<item>
<title>New APIs for Domino JNA project, now available for XPages development</title>
<pubDate>Mon, 16 Jan 2017 08:21:26 +0200</pubDate>
<description>
<![CDATA[
It took some time (mainly because I was very busy and my main use case for the project is not XPages), but now the Domino JNA project is available for XPages development. That means that there is an ...
]]>
</description>
<link>https://www.mindoo.com/web/blog.nsf/dx/16.01.2017082125KLEAMY.htm</link>
<category>Domino C API</category>
<dc:creator>Karsten Lehmann</dc:creator>
<comments>https://www.mindoo.com/web/blog.nsf/dx/16.01.2017082125KLEAMY.htm?opendocument&comments</comments>
<guid isPermaLink="true">https://www.mindoo.com/web/blog.nsf/dx/16.01.2017082125KLEAMY.htm</guid>
<content:encoded><![CDATA[ It took some time (mainly because I was very busy and my main use case for the project is not XPages), but now the Domino JNA project is available for XPages development. That means that there is an XPages Extensibility API plugin available in the <a href="https://github.com/klehmann/domino-jna/releases" target=_blank>project's release section on Github</a> that can be installed both in Domino Designer and on the Domino R9 server to use the API in your own applications. After installation, the API classes are available in SSJS and Java code including API source code. Since they are integrated with the JSF lifecycle, memory management is automatically handled by the plugin. That means that code using the API does not have to be wrapped in <code>NotesGC.runWithAutoGC()</code> blocks to automatically recycle allocated C handles and memory after a HTTP request. If you want to build your own release of the project (or of your own fork), please take a look at the section "<a href="https://github.com/klehmann/domino-jna#using-domino-jna-in-xpages-applications" target=_blank>Using Domino JNA in XPages applications</a>". The Maven build has been tested on macOS and Windows. New features Tons of new features have been added to the project during the last months. It's difficult to keep up with test cases and extend code documentation. Here are a few highlights: <ul> <li>new APIs to use native <a href="https://github.com/klehmann/domino-jna/blob/master/domino-jna/src/test/java/com/mindoo/domino/jna/test/TestTransactions.java" target=_blank>NSF transactions</a> (atomically create/modify/delete multiple documents in a database, see the <a href="https://github.com/klehmann/domino-jna/blob/master/domino-jna/src/main/java/com/mindoo/domino/jna/transactions/Transactions.java" target=_blank>Transactions class</a> for known issues/limitations) </li><li>new APIs to read the <a href="https://github.com/klehmann/domino-jna/blob/master/domino-jna/src/main/java/com/mindoo/domino/jna/ecl/ECL.java" target=_blank>ECL for a specific user</a> </li><li>API to let NSF quickly filter a number of documents with a formula (not just the whole database as in IBM's Java API): <code><a href="https://github.com/klehmann/domino-jna/blob/master/domino-jna/src/main/java/com/mindoo/domino/jna/NotesIDTable.java" target=_blank>NotesIDTable.filter(NotesDatabase db, String formula)</a></code> </li><li>support added to direct attachment streaming to <a href="https://github.com/klehmann/domino-jna/blob/master/domino-jna/src/main/java/com/mindoo/domino/jna/NotesAttachment.java" target=_blank>quickly skip a number of bytes</a> (can be used to implement partial downloads via <code>Accept-Ranges</code> HTTP header, restricted to uncompressed attachments) </li><li>APIs to read/write database options with more than 100 available option constants (IBM's Java API contains only 13 of them) </li><li>Reading selected view rows specified as an ID table now also works on remote servers (use <a href="https://github.com/klehmann/domino-jna/blob/master/domino-jna/src/main/java/com/mindoo/domino/jna/NotesCollection.java" target=_blank>NotesCollection.updateFilters()</a> to push your SelectedList ID table changes to remote servers before reading data) </li><li>Performance enhancements when inserting many IDs to a NotesIDTable</li></ul> To achieve the new functionality, lots of undocumented C API methods have been used that IBM should really add to the public API: <ul> <li>NIFReadEntriesExt </li><li>NIFIsNoteInView </li><li>NIFIsUpdateInProgress </li><li>NIFGetIDTableExtended </li><li>NIFCollectionUpToDate </li><li>NIFUpdateFilters </li><li>NIFIsTimeVariantView </li><li>IDScanBack </li><li>IDInsertRange </li><li>IDTableDifferences </li><li>IDTableReplaceExtended </li><li>ECLGetListCapabilities </li><li>NSFSearchExtended3 </li><li>NSFDbGetOptionsExt </li><li>NSFDbSetOptionsExt </li><li>NSFTransactionBegin </li><li>NSFTransactionCommit </li><li>NSFTransactionRollback </li><li>extended <a href="https://github.com/klehmann/domino-jna/blob/master/domino-jna/src/main/java/com/mindoo/domino/jna/constants/Find.java" target=_blank>FIND_XXX flags</a> e.g. FIND_CATEGORY_MATCH to look up category rows in views </li><li>more than 100 DBOPTBIT_XXX constants to read/write database options</li></ul> Please let me know if there are any problems using the API. ]]></content:encoded>
<wfw:commentRss> https://www.mindoo.com/web/blog.nsf/dxcomments/16.01.2017082125KLEAMY.htm</wfw:commentRss>
<wfw:comment> https://www.mindoo.com/web/blog.nsf/dx/16.01.2017082125KLEAMY.htm?opendocument&comments</wfw:comment>
</item>
<item>
<title>My latest wish list for the Domino Java API</title>
<pubDate>Thu, 3 Nov 2016 11:10:49 +0200</pubDate>
<description>
<![CDATA[
Last week I sent an email with enhancement ideas for the Domino Java API to IBM development. Most of the stuff listed here (except new @-functions) can be implemented by wrapping existing C API functi ...
]]>
</description>
<link>https://www.mindoo.com/web/blog.nsf/dx/03.11.2016111046KLEDXT.htm</link>
<category>Domino C API</category>
<dc:creator>Karsten Lehmann</dc:creator>
<comments>https://www.mindoo.com/web/blog.nsf/dx/03.11.2016111046KLEDXT.htm?opendocument&comments</comments>
<guid isPermaLink="true">https://www.mindoo.com/web/blog.nsf/dx/03.11.2016111046KLEDXT.htm</guid>
<content:encoded><![CDATA[ Last week I sent an email with enhancement ideas for the Domino Java API to IBM development. Most of the stuff listed here (except new @-functions) can be implemented by wrapping existing C API functions or simple copy&paste of already existing code. We already did this using our <a href="https://github.com/klehmann/domino-jna" target=_blank>Domino JNA</a> project, but I thought it would be a good idea to add this functionality to the standard API and provide full platform support. I don't really have unrealistic expectations whether this will ever be added to the product, given the latest speed new features got in, but I haven't given up hope yet. I am posting this here in the blog in case it is interesting for anyone. 1. ViewNavigator View.createViewNavForSelection(int[] noteIds) Filter a view navigator to only return entries with specified note ids, e.g. received via previous lookups. Using the C API, this can be done by opening the view with NIFOpenCollection and populating the ID table "rethSelectedList": <code>STATUS LNPUBLIC NIFOpenCollection( DBHANDLE hViewDB, DBHANDLE hDataDB, NOTEID ViewNoteID, WORD OpenFlags, HANDLE hUnreadList, HCOLLECTION far *rethCollection, NOTEHANDLE far *rethViewNote, UNID far *retViewUNID, HANDLE far *rethCollapsedList, HANDLE far *rethSelectedList);</code> To navigate the view, NIFReadEntries would be called with NAVIGATE_NEXT_SELECTED / NAVIGATE_PREV_SELECTED flag. 2. int[] View.getAllIdsByKey(Object key, boolean exact) Convenience function to only read the note ids of view entries matching the lookup key for better performance (less data in the summary buffer returned from NIFReadEntries, so more rows read with one C API call). Using the C API, this can be done with NIFReadEntries calls where only READ_MASK_NOTEID is used as return data mask. 3. View.getViewEntryByKeyWithOptions(Object startKey, int searchOptions) This function is already available in the XPages runtime and would need to be copied over to the Domino Java API. The AbstractDominoViewPickerData class in the Extension Library uses it to locate view entries with a search key greater or equal "X": <a href="https://github.com/the-ntf/xspstarterkit/blob/master/extlib/com.ibm.xsp.extlib.domino/src/com/ibm/xsp/extlib/component/picker/data/AbstractDominoViewPickerData.java#L221">https://github.com/the-ntf/xspstarterkit/blob/master/extlib/com.ibm.xsp.extlib.domino/src/com/ibm/xsp/extlib/component/picker/data/AbstractDominoViewPickerData.java#L221</a> <code>ViewEntry ve=null; String startKey = options.getStartKey(); if(startKey!=null) {         int searchOptions = DominoUtils.FIND_GREATER_THAN|DominoUtils.FIND_EQUAL|DominoUtils.FIND_PARTIAL|DominoUtils.FIND_CASE_INSENSITIVE;         ve = DominoUtils.getViewEntryByKeyWithOptions(view, startKey, searchOptions); } else {         ve=nav.getCurrent(); }</code> So this gives us a way to do inequality searches for Strings and Numbers in views and decide if keys need to be case sensitive. These functions can be combined to implement powerful view lookups, e.g. filter view entries by multiple column values and sort the result dynamically. Here is an example: <code>View myView = db.getView("MyView"); myView.setAutoUpdate(false); //resort view by first sort column myView.resortView("firstsortcolumn", true); //get matches for first search key int[] noteIdsFirstKey = myView.getAllIdsByKey(firstSearchKey, false); //resort view by second sort column myView.resortView("secondsortcolumn", true); //get matches for second search key int[] noteIdsSecondKey = myView.getAllIdsByKey(secondSearchKey, false); //intersect both note ids lists: list1 AND list2 using some tool class int[] noteIdsFirstAndSecondKey = IDUtil.and(noteIdsFirstKey, noteIdsSecondKey); //resort view by third sort column myView.resortView("thirdsortcolumn", true); //get matches for third search key int noteIdsThirdKey = myView.getAllIdsByKey(thirdSearchKey, false); //merge intersection of first/second key matches with third: (list1 AND list2) OR list3 int[] noteIdsFirstAndSecondKeyOrThirdKey = IDUtil.or(noteIdsFirstAndSecondKey, noteIdsThirdKey); //and now we produce the final sorting: myView.resortView("finalsortcolumn", true); //we would need this API to reduce the view to entries with specified note ids with max performance (let NIF skip irrelevant collection entries for us) ViewNavigator nav = myView.createViewNavForSelection(noteIdsFirstAndSecondKeyOrThirdKey); nav.setCacheGuidance(400, ViewNavigator.VN_CACHEGUIDANCE_READSELECTIVE); //skip some view entries to support paging nav.skip(start); //write requested page data (start/count) in JSON format: ViewEntry veCurrent = nav.getCurrent(); while (veCurrent!=null && count>0) {         if (veCurrent.isValid()) {                 writeAsJson(veCurrent);                 count--;         }         //read next view entry matching our selection list         ViewEntry veNext = nav.getNext();         veCurrent.recycle();         veCurrent = veNext; }</code> This view lookup technique is already being used by us at a big Domino customer in Germany using C calls (Domino JNA project), but platform support is currently limited to those supported by JNA and this should really be part of the standard API. Other useful APIs to add: 4. @ModifiedInThisFile / @AddedToThisFile (posted in the Design Partner Forum in January 2014) Two new @-functions to sort view entries by the date their corresponding documents got added to/modified in the database. Required for synchronization of Domino data with external databases. Using @modified instead would not cover changes coming in via replication that happened before the cutoff date for the current data synchronization. Response to DP forum article in 2014 said the feature will be in 9.0.2, so it seems to be already implemented and would need to be added to a feature pack. 5. NoteCollection.add(int[] noteIds) Fast bulk add function to add many note ids at once to a NoteCollection for better performance. 6. int[] DocumentCollection.getNoteIDs() Fast method to get all note ids stored in a DocumentCollection as an int array. If DocumentCollection is sorted internally, the array should have the same sorting. Could be used in combination with "DocumentCollection Database.FTSearch()" to quickly get a note id list of documents matching a fulltext search. 7. int[] Database.getDeletedDocuments(DateTime since, int noteClass) Method to get a list of note ids for documents deleted since the specified datetime. C API function NSFDbGetModifiedNoteTable already returns deleted notes ORed with RRV_DELETED flag. So this function would simply copy this list to an int array. Already available method Database.getModifiedDocuments(DateTime since, int noteClass) is no help because it filters out deleted documents. Use case is data synchronisation between Domino databases and with external systems. ]]></content:encoded>
<wfw:commentRss> https://www.mindoo.com/web/blog.nsf/dxcomments/03.11.2016111046KLEDXT.htm</wfw:commentRss>
<wfw:comment> https://www.mindoo.com/web/blog.nsf/dx/03.11.2016111046KLEDXT.htm?opendocument&comments</wfw:comment>
</item>
<item>
<title>Big update for Domino JNA project on Github</title>
<pubDate>Mon, 11 Jul 2016 23:33:05 +0200</pubDate>
<description>
<![CDATA[
Last weekend, I committed a big update for the Domino JNA project on Github. Here is what's new: Note (Document) APIs The last weeks since creating the project, I added basic APIs to work with dat ...
]]>
</description>
<link>https://www.mindoo.com/web/blog.nsf/dx/11.07.2016233301KLETA8.htm</link>
<category>Domino C API</category>
<dc:creator>Karsten Lehmann</dc:creator>
<comments>https://www.mindoo.com/web/blog.nsf/dx/11.07.2016233301KLETA8.htm?opendocument&comments</comments>
<guid isPermaLink="true">https://www.mindoo.com/web/blog.nsf/dx/11.07.2016233301KLETA8.htm</guid>
<content:encoded><![CDATA[ Last weekend, I committed a big update for the <div align=center><a href="https://www.mindoo.com/web/blog.nsf/dx/08.04.2016191137KLEN6U.htm" title="08.04.2016191137KLEN6U.htm">Domino JNA project on Github</a>.</div> Here is what's new: Note (Document) APIs The last weeks since creating the project, I added basic APIs to work with database notes (documents). The main focus was to be able to read the classic note item value types, e.g. String, Number and Date/Time with single or multiple values per item, handle a few rarely known edge cases (e.g. multiline text values that Domino stores with delimiter \0 between the lines instead of platform dependent \n or \r\n), do proper LMBCS/Unicode conversion routines for special characters like Umlauts and provide access to item metadata like the sequence number or the last modified date of an item. While reading the note flag documentation, I discovered NOTE_FLAG_READONLY, which Domino automatically adds to the note info area. This note flag can be used to quickly check whether the current Domino user has edit access to a document without all the work of traversing all author items and manually compare the values to <code>@UserNamesList</code>. So that's what is being queried now when you call <code>NotesNote.isReadOnly()</code>. Attachment streaming Another thing I added was support for note attachment streaming. You probably know that IBM's (poor) implementation of <code>EmbeddedObject.getInputStream()</code> internally first extracts the file to a temp directory and then returns an <code>InputStream</code> to this temporary file. Depending on the file size, that may ruin application performance and fill disk space. So the Domino JNA way of reading attachment is to manually decode the $File items and read the file content in small chunks of 16K, the buffer size of the C function to read attachment data. The Domino C API provides some easy methods to set item values for selected data types (e.g. single values for text, number and Date/Time). I added them to the Domino JNA as well, but there is still work to do to write multiple values. A few other things that are new: User spoofing - reader items on steroids A <code>NAMES_LIST</code> data structure is what Domino returns when you call <code>NSFBuildNamesList</code> with a Domino username. This <code>NAMES_LIST</code> contains all name variants/wildcards and groups/nested groups on the server for the specified username. It is passed as a parameter when you open a database or a view so that Domino can compute document visibility (reader items) and write access rights. Ever since writing the code to decode this simple memory data structure, I was asking myself whether it can be built programatically, because it's just the number of names and the null terminated LMBCS encoded list of names. And since I need that functionality for an upcoming customer project (Google+ like application with very flexible read access rights for postings), I tried it and it worked like a charm. :-) So now you can <a href="https://github.com/klehmann/domino-jna/blob/master/domino-jna/src/test/java/com/mindoo/domino/jna/test/TestNamesListCreation.java" target=_blank>build your own Domino users at runtime</a> that do not have to be in a Domino directory. Just pass a Java List with name variants in the NotesDatabase constructor and all operations are executed on behalf of that user. Unification of view column value reading Domino has two ways to read view column data: <code>READ_MASK_SUMMARY</code> which returns programmatic column names and their values in the summary buffer and <code>READ_MASK_SUMMARYVALUES</code> that just returns the column values. The latter leaves more space in the summary buffer for data, as the column names never change between view entries. Unfortunately, one new optimized lookup call that IBM added in R9 to atomically look up a key and start reading values, currently only works with <code>READ_MASK_SUMMARY</code>. I don't think that developers should care about this difference, so I now handle all that internally in the NotesViewEntryData object and you simply call <code>NotesViewEntryData.get("Firstname")</code> to read a column value. Here is a <a href="https://github.com/klehmann/domino-jna/blob/master/domino-jna/src/test/java/com/mindoo/domino/jna/test/TestViewTraversal.java" target=_blank>test case</a> to see some sample code for view data reading (the API has changed compared to the initial release). Performance optimizations I did some profiler sessions and optimized the API for performance. The main optimization was to add an LMBCS string decoder cache that reduces the string conversion operations and to lazily convert strings when they are first needed (e.g. when reading only a few view column values). The code on Github was tested on Mac 64 bit and Windows 32 bit clients so far. The next days, I will do further tests with Windows 64 bit servers since we are using the API in multiple customer projects. The repository contains various test cases to get started. ]]></content:encoded>
<wfw:commentRss> https://www.mindoo.com/web/blog.nsf/dxcomments/11.07.2016233301KLETA8.htm</wfw:commentRss>
<wfw:comment> https://www.mindoo.com/web/blog.nsf/dx/11.07.2016233301KLETA8.htm?opendocument&comments</wfw:comment>
</item>
<item>
<title>New on Github: Domino JNA - Cross-platform access to IBM Notes/Domino C API methods from Java</title>
<pubDate>Fri, 8 Apr 2016 19:11:37 +0200</pubDate>
<description>
<![CDATA[
I would like to introduce you to a pet project that I have been working on for the last months: Domino JNA - Cross-platform access to IBM Notes/Domino C API methods from Java As you might have alre ...
]]>
</description>
<link>https://www.mindoo.com/web/blog.nsf/dx/08.04.2016191137KLEN6U.htm</link>
<category>Domino C API</category>
<dc:creator>Karsten Lehmann</dc:creator>
<comments>https://www.mindoo.com/web/blog.nsf/dx/08.04.2016191137KLEN6U.htm?opendocument&comments</comments>
<guid isPermaLink="true">https://www.mindoo.com/web/blog.nsf/dx/08.04.2016191137KLEN6U.htm</guid>
<content:encoded><![CDATA[ I would like to introduce you to a pet project that I have been working on for the last months: <div align=center><div style="font-size:14px">Domino JNA - Cross-platform access to IBM Notes/Domino C API methods from Java</div></div> As you might have already read <a href="https://www.mindoo.com/web/blog.nsf/dx//web/blog.nsf/dx/31.03.2010220936KLERN4.htm?opendocument&comments" target=_blank>in this blog</a> in the past, we have been playing with the Domino C API for some time now and found out that you can speed up view reading dramatically when you talk directly to the C API instead of using IBM's Java classes. The C API also provides lots of other functionality for which no Java or LotusScript methods exist yet. It has always been possible to build your own DLL with C code calling Domino methods and use it via Java's Native Interface (JNI). We did this in applications developed for customers and partners, e.g. to render Richtext to HTML format, directly stream attachments (IBM's API first stores files temporarily to disk, not a good idea) or replicate databases with a progress callback. But the problem has always been that the native code has to be compiled for each platform. JNA to the rescue <a href="https://github.com/java-native-access/jna" target=_blank>Java Native Access</a> is a project that gives Java developers access to native shared libraries without creating their own DLL or library file. You simply call Java methods and make sure that your method arguments match those on the C side. So I created my first small sample application months ago calling some Domino code, found out that it worked in Windows 32 bit, found out that I had to change something for Windows 64 bit to get more than just crashes, found out that the whole stuff did nothing than crashing in Linux systems, read lots of Domino C API documentation, build testcases, documented the API methods.... ...and months later I uploaded the whole stuff to Github. :-) Here it is: <div align=center><div style="font-size:14px"><a href="https://github.com/klehmann/domino-jna" target=_blank>https://github.com/klehmann/domino-jna</a></div></div> An API is nothing without documentation and sample code. And I am working on that, but this takes time. There are already a few testcases available for the view functions. Since talking to low level functions is not what everybody likes, I am also creating helper functions that make working with the API easier. I rename stuff, I add stuff and hide stuff. So please be aware that this project is definitely not finish and will change, but I want to share the code today because it already creates value and works quite well for us. What does it do already? Here are some of the things you can do with the first version: <ul> <li>view lookups using different key formats (e.g. strings, numbers, dates, date ranges) and equality/inequality searches (e.g. find less or greater than a search key) </li><li>decodes all available types of view column data types (string, string list, number, number list, datetime, datetime list) and row data (e.g. just note id, UNID, counts, unread flag etc.) </li><li>read view data as another Notes user </li><li>separation of Notes views and their data into multiple databases (like programmatically creating private views and keeping them up-to-date incrementally) </li><li>special optimized functions for local databases (e.g. when API is running on the server and databases are on the server as well): <ul> </li><li>dynamic filtering of view rows based on a Note id list with paging support (this really rocks!) </li><li>reading categorized views with expanded/collapsed entries and min/max level</li></ul> <li>read design collection with design elements in a database </li><li>support for view resorting (changing the collation in C API terms) </li><li>fulltext index creation with all available options </li><li>supports incremental synchronization of Domino databases by reading noteid lists of modified and deleted documents (IBM's Java API does not return ids of deleted docs) </li><li>clearing the replication history </li><li>compute @Usernameslist values for any Notes user</li></ul> License The Github repository contains a Maven project with the API code and setup instructions. All is available under Apache 2.0 license. As next step, I want to add the code to an XPages Extension Library plugin to make it easier to use from XPages code. Please provide feedback if the project is working for you. ]]></content:encoded>
<wfw:commentRss> https://www.mindoo.com/web/blog.nsf/dxcomments/08.04.2016191137KLEN6U.htm</wfw:commentRss>
<wfw:comment> https://www.mindoo.com/web/blog.nsf/dx/08.04.2016191137KLEN6U.htm?opendocument&comments</wfw:comment>
</item>
<item>
<title>Updated on OpenNTF: Release 1.1 of Open Eclipse Update Site with Mac 64 Bit Client support and other cool stuff</title>
<pubDate>Fri, 4 Mar 2016 01:23:48 +0200</pubDate>
<description>
<![CDATA[
I have updated the OpenNTF project "Open Eclipse Update Site" with release version 1.1 and added the following useful features: added support for the Mac Notes Client with 64 bit new view action to ...
]]>
</description>
<link>https://www.mindoo.com/web/blog.nsf/dx/04.03.2016012344KLE2GW.htm</link>
<category>Free Tools</category>
<dc:creator>Karsten Lehmann</dc:creator>
<comments>https://www.mindoo.com/web/blog.nsf/dx/04.03.2016012344KLE2GW.htm?opendocument&comments</comments>
<guid isPermaLink="true">https://www.mindoo.com/web/blog.nsf/dx/04.03.2016012344KLE2GW.htm</guid>
<content:encoded><![CDATA[ I have updated the OpenNTF project <a href="https://www.openntf.org/main.nsf/project.xsp?r=project/Open%20Eclipse%20Update%20Site/releases/1D1B9316A4B47BAB86257F6C00021118" target=_blank>"Open Eclipse Update Site" with release version 1.1</a> and added the following useful features: <ul> <li>added support for the Mac Notes Client with 64 bit </li><li>new view action to extract selected features as an update site to disk (also available in headless mode via Java agents “(API)” and “(Java-API)“) </li><li>new view actions to install/uninstall selected features via rcplauncher based deployment, which is used by software distribution systems and should also work on clients where widget deployment is blocked via policy </li><li>new database icon</li></ul> Update: I had to renew the download package on 4th March 2016 and fixed/added the following items: <ul> <li>fixed bug where the rcplauncher deployment log could not be written for Notes data directories containing whitespaces </li><li>added alternative UI which can be activated via role [WidgetUILaunch]. Setting the role displays an install wizard on database open instead of the classic Update Site UI views. The wizard guides the user through a a widget (extension.xml) based plugin installation</li></ul> <img alt="Image:Updated on OpenNTF: Release 1.1 of Open Eclipse Update Site with Mac 64 Bit Client support and other cool stuff" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/04.03.2016012344KLE2GW.htm/content/M2?OpenElement" /> <img alt="Image:Updated on OpenNTF: Release 1.1 of Open Eclipse Update Site with Mac 64 Bit Client support and other cool stuff" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/04.03.2016012344KLE2GW.htm/content/M3?OpenElement" /> <img alt="Image:Updated on OpenNTF: Release 1.1 of Open Eclipse Update Site with Mac 64 Bit Client support and other cool stuff" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/04.03.2016012344KLE2GW.htm/content/M4?OpenElement" /> <img alt="Image:Updated on OpenNTF: Release 1.1 of Open Eclipse Update Site with Mac 64 Bit Client support and other cool stuff" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/04.03.2016012344KLE2GW.htm/content/M5?OpenElement" /> ]]></content:encoded>
<wfw:commentRss> https://www.mindoo.com/web/blog.nsf/dxcomments/04.03.2016012344KLE2GW.htm</wfw:commentRss>
<wfw:comment> https://www.mindoo.com/web/blog.nsf/dx/04.03.2016012344KLE2GW.htm?opendocument&comments</wfw:comment>
</item>
<item>
<title>Notes 9.0.1 64 bit for Mac OS X 10.11 El Capitan now available - warning our customers NOT to update for 30+ days!</title>
<pubDate>Tue, 29 Sep 2015 10:30:06 +0200</pubDate>
<description>
<![CDATA[
One day before the general availability of Mac OS X 10.11 (El Capitan), IBM released an update for their IBM Notes Client 9.0.1 with 64 bit support: http://www-01.ibm.com/common/ssi/cgi-bin/ssialias? ...
]]>
</description>
<link>https://www.mindoo.com/web/blog.nsf/dx/29.09.2015103005KLEBYV.htm</link>
<category>Lotus Notes 9</category>
<dc:creator>Karsten Lehmann</dc:creator>
<comments>https://www.mindoo.com/web/blog.nsf/dx/29.09.2015103005KLEBYV.htm?opendocument&comments</comments>
<guid isPermaLink="true">https://www.mindoo.com/web/blog.nsf/dx/29.09.2015103005KLEBYV.htm</guid>
<content:encoded><![CDATA[ One day before the general availability of Mac OS X 10.11 (El Capitan), IBM released an update for their IBM Notes Client 9.0.1 with 64 bit support: <a href="http://www-01.ibm.com/common/ssi/cgi-bin/ssialias?subtype=ca&infotype=an&appname=iSource&supplier=877&letternum=ENUSZP15-0483">http://www-01.ibm.com/common/ssi/cgi-bin/ssialias?subtype=ca&infotype=an&appname=iSource&supplier=877&letternum=ENUSZP15-0483</a> Previous versions were using Java 1.6 32 Bit under the hood, which was maintained by Apple for the last 7 years. Since Apple dropped support for Java 1.6 in OS X 10.11, IBM had to update their IBM Mac Notes Client to work with newer JVMs (1.7 and 1.8 are maintained by Oracle and are only available with 64 Bit). Unfortunately we now have to warn our customers not to update their OS X version and Notes environment for at least 30 days. The reason is that IBM will release the C API toolkit 30 days after the Notes Client availability, as mentioned in this <a href="http://www-01.ibm.com/support/docview.wss?uid=swg21962311" target=_blank>Q&A page</a>: NOTE: If you are running applications that make use of the Notes C API Toolkit, then you must recompile those application with the new 64-bit Mac API Toolkit, which is expected to be available approximately 30 days after Notes 9.0.1 64-bit ships. This technote will be updated when the C API Toolkit is available. Since the applications that we maintain on OS X for customers (such as <a href=http://www.mindplan.com/ target=_blank>MindPlan</a> or individual Notes Client add ons) contain native code, they need to be recompiled for 64 Bit, otherwise they will no longer work after the OS X update. We are asking IBM dev for a beta version of the C API toolkit to speed up this application update process, but have not received a positive response yet. BTW: It looks like there are no plans to move the Windows Notes Client to 64 bit. However, for Notes 9.0.2 it is planned to ship it with IBM's JVM version 1.8. IBM will announce their release plan for 9.0.2 in January at IBM Connect. Update: Looks like there is Java 6 support in El Capitan and the old 32 bit Notes Client is still working. See the comments for details. ]]></content:encoded>
<wfw:commentRss> https://www.mindoo.com/web/blog.nsf/dxcomments/29.09.2015103005KLEBYV.htm</wfw:commentRss>
<wfw:comment> https://www.mindoo.com/web/blog.nsf/dx/29.09.2015103005KLEBYV.htm?opendocument&comments</wfw:comment>
</item>
<item>
<title>New C API method NIFFindByKeyExtended2 in Domino 9.0 improves view lookups</title>
<pubDate>Fri, 6 Mar 2015 14:48:54 +0200</pubDate>
<description>
<![CDATA[
Once again I am digging into the Notes/Domino C API to implement fast and powerful view lookups. What caused it this time was a customer requirement for "Notes Client style keyboard navigation" in web ...
]]>
</description>
<link>https://www.mindoo.com/web/blog.nsf/dx/06.03.2015144848KLEJ83.htm</link>
<category>Lotus Notes 9</category>
<dc:creator>Karsten Lehmann</dc:creator>
<comments>https://www.mindoo.com/web/blog.nsf/dx/06.03.2015144848KLEJ83.htm?opendocument&comments</comments>
<guid isPermaLink="true">https://www.mindoo.com/web/blog.nsf/dx/06.03.2015144848KLEJ83.htm</guid>
<content:encoded><![CDATA[ Once again I am digging into the Notes/Domino C API to implement fast and powerful view lookups. What caused it this time was a customer requirement for "Notes Client style keyboard navigation" in web views, meaning that you type a character, press enter and the cursor position should be moved to the relevant area of the view (e.g. where the content in the first sorted view column is greater or equal letter "L"). Using standard Java APIs for this purpose (ViewNavigator.getNextSibling(), until we find a greater column value) was much to slow, since the view had about 40,000 entries in the top level. We did a lot of experiments in this area in the past (<a href="https://www.mindoo.com/web/blog.nsf/dx/31.03.2010220936KLERN4.htm" target="_blank">1</a>, <a href="https://www.mindoo.com/web/blog.nsf/dx/25.04.2010235255KLETNN.htm" target="_blank"/>2</a>) writing custom DLLs for Windows/.so libraries for Linux, but this time my plan was to use <a href=https://github.com/twall/jna target=_blank>Java Native Access (JNA)</a> from an Eclipse plugin to build the code more quickly. I will try to publish some tool libraries in this area in the near future (as always I am very busy...). But in this post, I just want to document a method that is available in the C API since 9.0 and has not been documented in the C API tookit since then. The method is called NIFFindByKeyExtended2 (the C API release notes say NIFFindByKeyExtented2) and is only mentioned a few times on the web, e.g. in Scott Souder's <a href="http://sssouder.com/ssouder/ssouder.nsf/dx/now-available-notesdomino-9.0-c-api-toolkit" target=_blank>C API toolkit announcement post</a>. Here is the method signature: <code>STATUS far PASCAL NIFFindByKeyExtended2 (HCOLLECTION hCollection,                 void *KeyBuffer, DWORD FindFlags,                 DWORD ReturnFlags,                 COLLECTIONPOSITION *retIndexPos,                 DWORD *retNumMatches,                 WORD *retSignalFlags,                 DHANDLE *rethBuffer,                 DWORD *retSequence)</code> I asked IBM dev about the method and got the information that it combines NIFFindByKey and NIFReadEntries in one call. In earlier Domino releases, you had to use NIFFindByKey to get the view entry position for a search key and then use NIFReadEntries to read the view data. Unfortunately the view could have changed in the meantime so that the postion could point to a different location. This is not the case for NIFFindByKeyExtended2, which is executed atomically with a read lock on the view. For remote calls, the returned data can have up to 64 KB of content. If more data is required, subsequent calls to NIFReadEntries have to be made. For local calls, the main use case for XPages apps, the buffer has no limit. Here is the complete method documentation: <code> /*        NIFFindByKeyExtended2 - Lookup index entry by "key" * *        Given a "key" buffer in the standard format of a summary buffer, *        locate the entry which matches the given key(s).  Supply as many *        "key" summary items as required to correspond to the way the index *        collates, in order to uniquely find an entry. * *        If multiple index entries match the specified key (especially if *        not enough key items were specified), then the index position of *        the FIRST matching entry is returned ("first" is defined by the *        entry which collates before all others in the collated index). * *        Note that the more explicitly an entry can be specified (by *        specifying as many keys as possible), then the faster the lookup *        can be performed, since the "key" lookup is very fast, but a *        sequential search is performed to locate the "first" entry when *        multiple entries match. * *        This routine can only be used when dealing with notes that do not *        have multiple permutations, and cannot be used to locate response *        notes. * * Inputs: * *        hCollection = Handle of per-user collection context *        KeyBuffer = Address of "key" summary buffer *        FindFlags = Find flags word (FIND_xxx) *        ReturnMask = Mask specifying what information is to be returned on each entry *                                        (READ_MASK_xxx).  Information is always returned in the *                                        order of the bits which are 1, from bit 0 to bit 15. *        retIndexPos = Place to receive index position of (first) matching entry *        retNumMatches = Place to receive # entries which match (optional) *        retSignalFlags = Place to receive extra sharing warning flags (optional) * * Outputs: * *        (Routine) = Error status (ERR_NOT_FOUND if none found at all) *        *retIndexPos = Index position of (first) matching index entry. *        *retNumMatches = # matching entries *        *rethBuffer = Handle of return buffer (may be NULLHANDLE) *        *retBufferLength = Length of return buffer *        *retSequence = Index Modified Sequence number */ </code> Based on searches on the internet, there also seems to be NIFFindByKeyExtended3, but I don't have information about parameters and purpose for this method yet. ]]></content:encoded>
<wfw:commentRss> https://www.mindoo.com/web/blog.nsf/dxcomments/06.03.2015144848KLEJ83.htm</wfw:commentRss>
<wfw:comment> https://www.mindoo.com/web/blog.nsf/dx/06.03.2015144848KLEJ83.htm?opendocument&comments</wfw:comment>
</item>
<item>
<title>Tools we use to build web apps</title>
<pubDate>Sun, 21 Sep 2014 21:50:48 +0200</pubDate>
<description>
<![CDATA[
In a recent comment in this blog, Andrew Magerman asked what frameworks I use to build web applications and whether we have looked into Angular. Since the answer got too long for a simple comment and ...
]]>
</description>
<link>https://www.mindoo.com/web/blog.nsf/dx/21.09.2014215044KLERAA.htm</link>
<category>Webdev</category>
<dc:creator>Karsten Lehmann</dc:creator>
<comments>https://www.mindoo.com/web/blog.nsf/dx/21.09.2014215044KLERAA.htm?opendocument&comments</comments>
<guid isPermaLink="true">https://www.mindoo.com/web/blog.nsf/dx/21.09.2014215044KLERAA.htm</guid>
<content:encoded><![CDATA[ In a recent <a href="https://www.mindoo.com/web/blog.nsf/dx//web/blog.nsf/dx/16.07.2009095816KLEBCY.htm?opendocument&comments#09212014083953PMSERPVY.htm" target=_blank>comment</a> in this blog, Andrew Magerman asked what frameworks I use to build web applications and whether we have looked into Angular. Since the answer got too long for a simple comment and might be interesting for others, I created this blog article. Server side I am using my own regexp based templating system, which simply fills some placeholders in static HTML and JS files and sends them to the browser, e.g. to compute URLs, to insert translated phrases and include content of other template files. I don't need much flexibility for this template system, because all dynamic stuff is created in the browser anyway. Data is provided via custom REST services implemented in Java that offer CRUD operations. In many cases, the server side application code uses framework classes from OSGi plugins that build a common layer shared between multiple web applications. Frontend stuff For the frontend, I use <a href=http://getbootstrap.com/ target=_blank>Bootstrap</a> to build responsive user interfaces that work on phones, tables and desktop browsers. I use <a href=http://jquery.com/ target=_blank>jQuery</a>, lots of helper projects like bootstrap <a href="http://eternicode.github.io/bootstrap-datepicker/?#sandbox" target=_blank>datepicker</a> and <a href="http://jdewit.github.io/bootstrap-timepicker/" target=_blank>timepicker</a>, <a href=http://ivaynberg.github.io/select2/ target=_blank>select2</a> for flexible comboboxes, <a href=https://github.com/julianshapiro/velocity target=_blank>velocity.js</a> for animations, <a href=https://github.com/getify/asynquence target=_blank>Asynquence</a> to work with callbacks and other libraries that I <a href=https://twitter.com/klehmann79/ target=_blank>tweeted</a> about in the past. To wire them together I use <a href=http://requirejs.org/ target=_blank>require.js</a>, which gives me a clean dependency resolution. React based UI rendering For more and more UI components, I use <a href=http://facebook.github.io/react/ target=_blank>React</a> for the rendering and their <a href="http://facebook.github.io/react/docs/flux-overview.html" target=_blank>flux application architecture</a>. I especially like their approach to reduce DOM changes by comparing old and new in a virtual DOM tree in memory when data changes. Another advantage of React.JS is that the initial UI code can be precomputed on the server side to improve SEO ranking (see <a href="http://blog.risingstack.com/from-angularjs-to-react-the-isomorphic-way/" target=_blank>this article</a>). Normally, this is done in code running in a Node.JS server. For Java based server environments like IBM Domino, we have code to do this using the JavaScript engine of the JVM and as an alternative (with better performance thanks to Node's V8 JavaScript engine) by leveraging an external Node.JS process on the same or a different machine. Angular We haven't used Angular in real-life projects yet. Looking at the documentation, it feels as if they over-standardized web application development a bit, making it more difficult than necessary to get started. What concerns me is that their <a href="http://www.williambrownstreet.net/blog/2014/04/faster-angularjs-rendering-angularjs-and-reactjs/" target=_blank>templating system does not seem to optimize DOM operations as good as React does</a>. In the browser, it's all about responsiveness and performance. What I don't use Personally I prefer not to use JSF components or <a href=https://vaadin.com/home target=_blank>similar concepts</a> for the web UI. I don't like to depend on a server state and don't like to have too much communication between frontend and backend. Instead I like to have most of the UI code in the browser so that the app is responsive even with bad network coverage. In addition, I can optimize DOM rendering and have more ways to play with animations and transitions. Communication with the server side is done through REST APIs that can also be reused to test functionality, automate tasks or for automatic data imports/updates. Domino? You may have noticed that not much of my way to develop web applications requires a Domino server. Having Domino on the server is a great thing, as it includes many services in one consistent platform, like the document database, fulltext search, directory services, replication and a close integration of application code and the mail server. But there's more than one way to skin a cat. We have prototypes in the lab that don't have any Domino dependencies. Since we like document databases combined with replication, we have been playing with the CouchDB eco system for some time: the Apache <a href=http://couchdb.apache.org/ target=_blank>CouchDB</a> project that is currently merged with the <a href=https://cloudant.com/ target=_blank>Cloudant</a> database and the <a href=https://github.com/rcouch/rcouch target=_blank>rcouch</a> project as well as its mobile version <a href=https://github.com/couchbase target=_blank>Couchbase Lite</a> and <a href=http://pouchdb.com/ target=_blank>PouchDB</a> in the browser. Combined with an OSGi based server platform, that looks like a powerful and extensible app dev environment. ]]></content:encoded>
<wfw:commentRss> https://www.mindoo.com/web/blog.nsf/dxcomments/21.09.2014215044KLERAA.htm</wfw:commentRss>
<wfw:comment> https://www.mindoo.com/web/blog.nsf/dx/21.09.2014215044KLERAA.htm?opendocument&comments</wfw:comment>
</item>
<item>
<title>Status report / collection of web and mobile development frameworks and tools</title>
<pubDate>Fri, 27 Jun 2014 09:49:20 +0200</pubDate>
<description>
<![CDATA[
The last post in this blog has been written 6 months ago. Although I have had several ideas for new posts, project work and family life got in the way (our son was born last September). At Mindoo, w ...
]]>
</description>
<link>https://www.mindoo.com/web/blog.nsf/dx/27.06.2014094920KLEB7E.htm</link>
<category></category>
<dc:creator>Karsten Lehmann</dc:creator>
<comments>https://www.mindoo.com/web/blog.nsf/dx/27.06.2014094920KLEB7E.htm?opendocument&comments</comments>
<guid isPermaLink="true">https://www.mindoo.com/web/blog.nsf/dx/27.06.2014094920KLEB7E.htm</guid>
<content:encoded><![CDATA[ The last post in this blog has been written 6 months ago. Although I have had several ideas for new posts, project work and family life got in the way (our son was born last September). At Mindoo, we have been incredibly busy working on development projects and product prototypes. Some of them are still IBM Domino based with Responsive Web Design using <a href=http://getbootstrap.com/ target=_blank>Bootstrap</a> and <a href=http://jquery.com/ target=_blank>jQuery</a> or Sencha's <a href=http://www.sencha.com/products/extjs/ target=_blank>ExtJS</a>, others are pure JSF applications using the <a href=http://www.primefaces.org/ target=_blank>Primefaces</a> framework. In other projects, we produced <a href=en.wikipedia.org/wiki/EPUB target=_blank>EPub</a> files from IBM Domino data (we used <a href=http://www.siegmann.nl/epublib target=_blank>EPublib</a> for this purpose), built some native extensions to call Domino C API functions from Java code (e.g. direct attachment streaming without extracting files to disk first) and dived a bit into the mobile development space with apps developed with <a href=http://www.appcelerator.com/titanium/ target=_blank>Appcelerator Titanium</a> and a CouchDB on the server side as well as <a href=https://github.com/pegli/ti_touchdb target=_blank>Couchbase lite</a> in the mobile client to easily sync data between devices. Since I could not find the time to write blog articles, I more and more have been using Twitter to publish interesting frameworks and tools. I do this primarily for myself to be able to find them later when I need a tool for a project, but hey, my Twitter account is open, so feel free to take a look or become a follower. To be able to search my findings, I created a Notes database on our web server where I download my tweets, add content of linked web pages and use Domino's powerful fulltext search engine for searching. That database currently only has an ugly Notes Client based user interface, but I plan to add a simple web frontend to it. We'll see if and when this will be available. So for now, all I can do is recommend taking a look at my Twitter account to see what technology I am currently working with: <div align=center><a href=http://twitter.com/klehmann79 target=_blank>http://twitter.com/klehmann79</a></div> ]]></content:encoded>
<wfw:commentRss> https://www.mindoo.com/web/blog.nsf/dxcomments/27.06.2014094920KLEB7E.htm</wfw:commentRss>
<wfw:comment> https://www.mindoo.com/web/blog.nsf/dx/27.06.2014094920KLEB7E.htm?opendocument&comments</wfw:comment>
</item>
<item>
<title>Now on OpenNTF: Open Eclipse Update Site - based on IBM’s template but with extended functionality</title>
<pubDate>Fri, 6 Dec 2013 19:16:01 +0200</pubDate>
<description>
<![CDATA[
I just created a new project on OpenNTF called "Open Eclipse Update Site". The Open Eclipse Update Site database is based on the OpenNTF project "Eclipse Update Site (updatesite.ntf)" from IBM with a ...
]]>
</description>
<link>https://www.mindoo.com/web/blog.nsf/dx/06.12.2013191601KLEPF4.htm</link>
<category>Free Tools</category>
<dc:creator>Karsten Lehmann</dc:creator>
<comments>https://www.mindoo.com/web/blog.nsf/dx/06.12.2013191601KLEPF4.htm?opendocument&comments</comments>
<guid isPermaLink="true">https://www.mindoo.com/web/blog.nsf/dx/06.12.2013191601KLEPF4.htm</guid>
<content:encoded><![CDATA[ I just created a new project on OpenNTF called "<a href="http://www.openntf.org/internal/home.nsf/project.xsp?action=openDocument&name=Open%20Eclipse%20Update%20Site" target=_blank>Open Eclipse Update Site</a>". The Open Eclipse Update Site database is based on the OpenNTF project "Eclipse Update Site (updatesite.ntf)" from IBM with additional functionality, e.g. <ul> <li>Mac Notes Client support (no SWT error messages like in the original template) </li><li>View action to delete selected features from the database (no need to delete all like in the original template) </li><li>Support for headless builds (automatic generation of update site, e.g. in a Jenkins server): database contains an agent called "(API)" that can be called to delete all content and import an update site from the local disk</li></ul> ]]></content:encoded>
<wfw:commentRss> https://www.mindoo.com/web/blog.nsf/dxcomments/06.12.2013191601KLEPF4.htm</wfw:commentRss>
<wfw:comment> https://www.mindoo.com/web/blog.nsf/dx/06.12.2013191601KLEPF4.htm?opendocument&comments</wfw:comment>
</item>
<item>
<title>Now on OpenNTF: Mindoo XPages2Eclipse - Eclipse APIs for XPiNC applications!</title>
<pubDate>Thu, 28 Nov 2013 19:45:49 +0200</pubDate>
<description>
<![CDATA[
I just created a new project on OpenNTF: Mindoo XPages2Eclipse. Our toolkit, which provides extensive Eclipse APIs to XPages developers in the IBM Notes Client (XPiNC), is now available for free! H ...
]]>
</description>
<link>https://www.mindoo.com/web/blog.nsf/dx/28.11.2013194548KLEPZP.htm</link>
<category>Free Tools</category>
<dc:creator>Karsten Lehmann</dc:creator>
<comments>https://www.mindoo.com/web/blog.nsf/dx/28.11.2013194548KLEPZP.htm?opendocument&comments</comments>
<guid isPermaLink="true">https://www.mindoo.com/web/blog.nsf/dx/28.11.2013194548KLEPZP.htm</guid>
<content:encoded><![CDATA[ I just created a new project on OpenNTF: <a href="http://www.openntf.org/internal/home.nsf/project.xsp?action=openDocument&name=Mindoo%20XPages2Eclipse" target=_blank>Mindoo XPages2Eclipse</a>. Our toolkit, which provides extensive Eclipse APIs to XPages developers in the IBM Notes Client (XPiNC), <div align=center>is now available for free!</div> Here is the project description: XPages2Eclipse is a language extension for XPages-development within the Lotus Notes Client Find out how XPages2Eclipse simplifies the development of XPages-applications for the IBM Lotus Notes Client considerably. With the help of this extensive toolkit you will be able to develop applications, which exhaust the full potential of the local client. XPages is the new technology of the hour for the notes/domino platform. It makes possible the development of modern and attractive applications in an up-to-date integrated development environment - the Domino Designer. For newcomers it is often difficult to master the XPages technology due to its extensive set of features - the change from classical Notes development with LotusScript is not to be accomplished within a couple of days. In addition to getting familiar with the usual Web standards like HTML, CSS and JavaScript, one also has to get to know the ui-library <a href=http://dojotoolkit.org/ target=_blank>Dojo</a>, as well as IBM specific additions like server side JavaScript (SSJS), themes or components from the <a href=http://extlib.openntf.org/ target=_blank>Domino Extension Library</a>. Yet, the result at the end of this steep learning curve is quite impressive: dynamic web user interfaces that can join data of multiple Lotus Notes databases or other data sources, if needed, or even an application for mobile devices – no traces left of the antiquated user interfaces that used to be created with classic Lotus Notes development. Thanks to the Lotus Notes Standard Client XPages applications can also be used locally and even offline. Expanding the boundaries of local XPages applications Unfortunately - from the perspective of developers - it is difficult or even impossible, to offer a set of features users are familiar with when executing XPages applications locally. That is, if developers stay within the boundaries of the XPages standard. There are hardly any standard APIs available to interact with the Lotus Notes Client or any other locally installed software. Missing are for example: <ul> <li>Integration of existing Notes applications: filling in Notes forms and Emails with data from XPages applications, accessing documents selected in classical Notes views, running existing LotusScript code </li><li>Import or export of data from IBM Lotus Symphony , supporting documents, spreadsheets and presentations </li><li>Executing document attachments with associated desktop-applications (for Windows, Linux and Mac OS) </li><li>Accessing the clipboard to store HTML, text, images or files </li><li>Executing long-running operations in the background, displaying their progress and cancelling the operation if necessary </li><li>Convenient features like file selection, including multi-selection, and folder selection</li></ul>But it doesn't have to be this way - XPages2Eclipse comes to your rescue. It enables developers to use functions of the Rich Client, without the need to become experts in either plugin- or Java development. Every feature of XPages2Eclipse can be used from within server side JavaScript. XPages2Eclipse offers something for everyone The requirements listed above are all met by XPages2Eclipse - and more! Your users will experience a real Rich Client-feeling for XPages applications within the IBM Lotus Notes Standard Client. As a developer you will save time and will be spared a lot of hard work to implement these functions, while enhancing consumer acceptance of your product. More information and sample code You can find lots of sample code and API documentation in the XPages2Eclipse wiki on the <a href=http://xpages2eclipse.mindoo.com/ target=_blank>XPages2Eclipse website</a>. ]]></content:encoded>
<wfw:commentRss> https://www.mindoo.com/web/blog.nsf/dxcomments/28.11.2013194548KLEPZP.htm</wfw:commentRss>
<wfw:comment> https://www.mindoo.com/web/blog.nsf/dx/28.11.2013194548KLEPZP.htm?opendocument&comments</wfw:comment>
</item>
<item>
<title>New on OpenNTF: Plugin to close XPiNC applications from CSJS code / to detect Notes ID changes</title>
<pubDate>Mon, 9 Sep 2013 22:06:28 +0200</pubDate>
<description>
<![CDATA[
There is a new project on OpenNTF that I created a few days ago: Mindoo Xulrunner Prefs.js Management Plugin. It's nothing big, only a small Eclipse plugin that can be installed in the Notes Client to ...
]]>
</description>
<link>https://www.mindoo.com/web/blog.nsf/dx/09.09.2013220628KLERL5.htm</link>
<category>XPages</category>
<dc:creator>Karsten Lehmann</dc:creator>
<comments>https://www.mindoo.com/web/blog.nsf/dx/09.09.2013220628KLERL5.htm?opendocument&comments</comments>
<guid isPermaLink="true">https://www.mindoo.com/web/blog.nsf/dx/09.09.2013220628KLERL5.htm</guid>
<content:encoded><![CDATA[ There is a new project on OpenNTF that I created a few days ago: <a href="http://www.openntf.org/internal/home.nsf/project.xsp?action=openDocument&name=Mindoo%20Xulrunner%20Prefs.js%20Management%20Plugin" target=_blank>Mindoo Xulrunner Prefs.js Management Plugin</a>. It's nothing big, only a small Eclipse plugin that can be installed in the Notes Client to manage the preferences of the Xulrunner engine that renders XPages in the Notes Client (XPiNC). The main purpose for this is to set the property "<code>dom.allow_scripts_to_close_windows</code>" to <code>false</code> on a number of machines (the plugin can be deployed via policy). This enables XPages applications to close their own tab in client-side JavaScript (CSJS), something that is not possible by default yet (last tested version: Notes Client R9). But the even more interesting part, at least for Eclipse plugin developers, is that the project demonstrates how to run code before and after the password prompt of IBM Notes. We use the following Extension Point: <code><<img alt="Image:New on OpenNTF: Plugin to close XPiNC applications from CSJS code / to detect Notes ID changes" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/09.09.2013220628KLERL5.htm/content/M2?OpenElement" />?xml version="1.0" encoding="UTF-8"?<img alt="Image:New on OpenNTF: Plugin to close XPiNC applications from CSJS code / to detect Notes ID changes" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/09.09.2013220628KLERL5.htm/content/M3?OpenElement" />> <<img alt="Image:New on OpenNTF: Plugin to close XPiNC applications from CSJS code / to detect Notes ID changes" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/09.09.2013220628KLERL5.htm/content/M4?OpenElement" />?eclipse version="3.4"?<img alt="Image:New on OpenNTF: Plugin to close XPiNC applications from CSJS code / to detect Notes ID changes" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/09.09.2013220628KLERL5.htm/content/M5?OpenElement" />> <<img alt="Image:New on OpenNTF: Plugin to close XPiNC applications from CSJS code / to detect Notes ID changes" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/09.09.2013220628KLERL5.htm/content/M6?OpenElement" />plugin<img alt="Image:New on OpenNTF: Plugin to close XPiNC applications from CSJS code / to detect Notes ID changes" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/09.09.2013220628KLERL5.htm/content/M7?OpenElement" />>    <<img alt="Image:New on OpenNTF: Plugin to close XPiNC applications from CSJS code / to detect Notes ID changes" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/09.09.2013220628KLERL5.htm/content/M8?OpenElement" />extension          point="com.ibm.rcp.lifecycle.application.startBundles"<img alt="Image:New on OpenNTF: Plugin to close XPiNC applications from CSJS code / to detect Notes ID changes" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/09.09.2013220628KLERL5.htm/content/M9?OpenElement" />>       <<img alt="Image:New on OpenNTF: Plugin to close XPiNC applications from CSJS code / to detect Notes ID changes" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/09.09.2013220628KLERL5.htm/content/M10?OpenElement" />application             id="com.ibm.rcp.personality.framework.RCPApplication"<img alt="Image:New on OpenNTF: Plugin to close XPiNC applications from CSJS code / to detect Notes ID changes" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/09.09.2013220628KLERL5.htm/content/M11?OpenElement" />>          <<img alt="Image:New on OpenNTF: Plugin to close XPiNC applications from CSJS code / to detect Notes ID changes" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/09.09.2013220628KLERL5.htm/content/M12?OpenElement" />bundle                id="com.mindoo.xpinc.changeprefs"<img alt="Image:New on OpenNTF: Plugin to close XPiNC applications from CSJS code / to detect Notes ID changes" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/09.09.2013220628KLERL5.htm/content/M13?OpenElement" />>          <<img alt="Image:New on OpenNTF: Plugin to close XPiNC applications from CSJS code / to detect Notes ID changes" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/09.09.2013220628KLERL5.htm/content/M14?OpenElement" />/bundle<img alt="Image:New on OpenNTF: Plugin to close XPiNC applications from CSJS code / to detect Notes ID changes" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/09.09.2013220628KLERL5.htm/content/M15?OpenElement" />>       <<img alt="Image:New on OpenNTF: Plugin to close XPiNC applications from CSJS code / to detect Notes ID changes" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/09.09.2013220628KLERL5.htm/content/M16?OpenElement" />/application<img alt="Image:New on OpenNTF: Plugin to close XPiNC applications from CSJS code / to detect Notes ID changes" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/09.09.2013220628KLERL5.htm/content/M17?OpenElement" />>    <<img alt="Image:New on OpenNTF: Plugin to close XPiNC applications from CSJS code / to detect Notes ID changes" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/09.09.2013220628KLERL5.htm/content/M18?OpenElement" />/extension<img alt="Image:New on OpenNTF: Plugin to close XPiNC applications from CSJS code / to detect Notes ID changes" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/09.09.2013220628KLERL5.htm/content/M19?OpenElement" />> <<img alt="Image:New on OpenNTF: Plugin to close XPiNC applications from CSJS code / to detect Notes ID changes" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/09.09.2013220628KLERL5.htm/content/M20?OpenElement" />/plugin<img alt="Image:New on OpenNTF: Plugin to close XPiNC applications from CSJS code / to detect Notes ID changes" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/09.09.2013220628KLERL5.htm/content/M21?OpenElement" />></code> The plugin code will actually get started a bit too early for our specific use case, because the user still has to enter his password, so no Notes session is available yet to read the Notes.ini content (or even find out where the Notes.ini is located). So we register an ILoginContextEventListener to get notified as soon as the user has logged in: <code>public void start(BundleContext bundleContext) throws Exception {         XPiNCChangePrefsActivator.context = bundleContext;                         //we register a ILoginContextEventListener to get notified when the         //user has logged into the platform         ILoginContextService service = SecurePlatform.getLoginContext();         service.addListener(new ILoginContextEventListener() {                 boolean hasTweakedPrefs = false;                                         public void handleLogin(LoginContextEvent event) {                 if (event.type == LoginContextEvent.MethodEnd && !event.hasException) {                         synchronized (XPiNCChangePrefsActivator.class) {                                 if (!hasTweakedPrefs) {                                         //we use a flag here, because the                                         //method is called twice                                         XPiNCPrefs.tweakXulrunnerPrefs();                                         hasTweakedPrefs=true;                                 }                         }                 }             }             public void handleLogout(LoginContextEvent event) {  }         }); }</code> This technique can also be used to detect Notes ID changes and is inspired by a <a href="https://www.ibm.com/developerworks/community/blogs/hmedney/date/201004?sortby=0&maxresults=10&lang=en" target=_blank>blog article of Hunter Medney</a>. Please note that there is another Extension Point in the Eclipse platform to launch code on startup, which is called after the user has logged in: <<img alt="Image:New on OpenNTF: Plugin to close XPiNC applications from CSJS code / to detect Notes ID changes" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/09.09.2013220628KLERL5.htm/content/M22?OpenElement" />extension point="org.eclipse.ui.startup"<img alt="Image:New on OpenNTF: Plugin to close XPiNC applications from CSJS code / to detect Notes ID changes" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/09.09.2013220628KLERL5.htm/content/M23?OpenElement" />>     <<img alt="Image:New on OpenNTF: Plugin to close XPiNC applications from CSJS code / to detect Notes ID changes" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/09.09.2013220628KLERL5.htm/content/M24?OpenElement" />startup class="com.mindoo.startuptest.MyStartupHandler" /<img alt="Image:New on OpenNTF: Plugin to close XPiNC applications from CSJS code / to detect Notes ID changes" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/09.09.2013220628KLERL5.htm/content/M25?OpenElement" />> <<img alt="Image:New on OpenNTF: Plugin to close XPiNC applications from CSJS code / to detect Notes ID changes" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/09.09.2013220628KLERL5.htm/content/M26?OpenElement" />/extension<img alt="Image:New on OpenNTF: Plugin to close XPiNC applications from CSJS code / to detect Notes ID changes" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/09.09.2013220628KLERL5.htm/content/M27?OpenElement" />> But the Extension Point we used for the plugin seems to be called a bit earlier, which reduces the risk that any sidebar panel or open tab that uses Xulrunner is opened before, which would prevent us from changing the prefs.js content permanently. ]]></content:encoded>
<wfw:commentRss> https://www.mindoo.com/web/blog.nsf/dxcomments/09.09.2013220628KLERL5.htm</wfw:commentRss>
<wfw:comment> https://www.mindoo.com/web/blog.nsf/dx/09.09.2013220628KLERL5.htm?opendocument&comments</wfw:comment>
</item>
<item>
<title>New on OpenNTF: Geospatial indexing for IBM Notes/Domino data</title>
<pubDate>Tue, 30 Jul 2013 23:11:37 +0200</pubDate>
<description>
<![CDATA[
Last weekend I created a new project on OpenNTF.org, which is part of a pretty big "pet project" that I have been working on for several month and that will hopefully be ready for primetime someday. ...
]]>
</description>
<link>https://www.mindoo.com/web/blog.nsf/dx/30.07.2013231136KLESUU.htm</link>
<category>Notesdev</category>
<dc:creator>Karsten Lehmann</dc:creator>
<comments>https://www.mindoo.com/web/blog.nsf/dx/30.07.2013231136KLESUU.htm?opendocument&comments</comments>
<guid isPermaLink="true">https://www.mindoo.com/web/blog.nsf/dx/30.07.2013231136KLESUU.htm</guid>
<content:encoded><![CDATA[ Last weekend I created a new project on OpenNTF.org, which is part of a pretty big "pet project" that I have been working on for several month and that will hopefully be ready for primetime someday. My original plan was to submit this pet project for the last XPages development contest, either in addition to or instead of the <a href="http://www.openntf.org/Internal/home.nsf/project.xsp?databaseName=CN=NotesOSS2/O=NotesOSS!!Projects\pmt.nsf&documentId=4040E0F28691008D86257AB00053F3BD&action=openDocument" target="_blank">Mindoo FTP Server</a>, but the project got bigger and bigger over time - and an FTP server was finally easier to polish and explain than my other idea. This idea has to do with alternative indexing techniques for IBM Notes/Domino data, something like "Notes Views on steroids": Building an external indexer for IBM Notes/Domino that is more powerful than classic Notes Views, but still easy to use and scalable for large amounts of data. And while I was investigating different open source indexers and database engines, I once again came across the topic "Geospatial Indexing", which I had already discussed in the article <a href="https://www.mindoo.com/web/blog.nsf/dx/27.04.2012185938KLEMXB.htm" target="_blank">XPages series #14: Using MongoDB’s geo-spatial indexing in XPages apps</a> Geospatial indexing basically solves the task to find locations stored in a database that are close to a given set of coordinates, specified as latitude/longitude pair and to sort the results by distance. With all those smartphones out there that carry a GPS chip, the requirement nowadays is pretty often to "find the next Italian restaurant" or "find friends nearby" that all can be solved with Geospatial Indexing. In my XPages series article I demonstrated how to use an external MongoDB database to do these kind of searches from XPages applications, but this stuff gets even more interesting and realistic if we can solve it with pure Notes/Domino technologies - and it is possible. There are a few obvious ways how Geospatial searches could be implemented with Notes/Domino APIs, e.g. Database.search(String), fulltext searching or just manually scanning through all view entries to find the relevant documents. The main problem is, that they either do not scale very well, because all documents of a database have to be scanned or they require the creation of a fulltext index, which I personally try to avoid for this kind of lookups (takes a lot of disk space, is often not up to date, sometimes issues with date searches, when Domino thinks a field is not a date/time, but a text). The solution: Geohashes After a few hours of searching, I found a document that explains how <a href="http://docs.mongodb.org/manual/core/geospatial-indexes/" target="_blank">MongoDB has implemented Geospatial Indexes</a>. They convert latitude/longitude pairs to a single string value, a so called <a href="http://en.wikipedia.org/wiki/Geohash" target="_blank">Geohash</a>. This way, a single prefix lookup is enough to search for both values. All you have to do is to compute the list of Geohash boxes that intersect the search area and find view entries that start with the right Geohash prefix: <div align=center><img alt="Image:New on OpenNTF: Geospatial indexing for IBM Notes/Domino data" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/30.07.2013231136KLESUU.htm/content/M2?OpenElement" /> (screenshot taken from the <a href="http://openlocation.org/geohash/geohash-js/" target="_blank">Geohash demonstrator</a> website)</div> Mindoo Geohash Demo The new project on OpenNTF that demonstrates the Geohash technique is called "<a href="http://www.openntf.org/internal/home.nsf/project.xsp?action=openDocument&name=Mindoo%20Geohash%20Demo" target="_blank">Mindoo Geohash Demo</a>" and it looks like this: <div align=center><img alt="Image:New on OpenNTF: Geospatial indexing for IBM Notes/Domino data" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/30.07.2013231136KLESUU.htm/content/M3?OpenElement" /></div> Project description The sample database can be used to store and search real-world locations. A location document consists of a name, a type (e.g. "Restaurant" or "Supermarket"), address information with street/zip/city/country and a field for other custom data. When entered via the web interface, we use the Google Geocoding API  to retrieve geo coordinates (latitude/longitude) for the address. These coordinates are stored alongside the other location data in the database. Location documents can also be created via a REST API call. <div align=center><img alt="Image:New on OpenNTF: Geospatial indexing for IBM Notes/Domino data" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/30.07.2013231136KLESUU.htm/content/M4?OpenElement" /> </div> The database also provides search functionality via web UI and REST API to quickly find the nearest locations for a given point (either entered as address or latitude/longitude pair), sorted in ascending distance. To get started, simply sign the database, copy it to your IBM Domino R9 server and open it in a browser. The database contains a sample dataset (all Starbucks stores in New York and Berlin, all Apple Stores in Germany) as a starting point, but this data can be deleted to start from scratch. To search for locations, enter an address (e.g. "Brandenburger Tor, Berlin, Germany") and the maximum distance in meters (e.g. 1000) in the search form and click the search button. You can further restrict the result set by specifying a location type (e.g. "Coffee"). Just select a type and leave the address field empty to see all locations with that type in the database. <div align=center><img alt="Image:New on OpenNTF: Geospatial indexing for IBM Notes/Domino data" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/30.07.2013231136KLESUU.htm/content/M5?OpenElement" /></div> For a visual representation of the search results, select up to 25 rows in the result list and they will get displayed via the Google Maps API. Hope you like the demo! All code and required libraries are available under Apache 2.0 license. ]]></content:encoded>
<wfw:commentRss> https://www.mindoo.com/web/blog.nsf/dxcomments/30.07.2013231136KLESUU.htm</wfw:commentRss>
<wfw:comment> https://www.mindoo.com/web/blog.nsf/dx/30.07.2013231136KLESUU.htm?opendocument&comments</wfw:comment>
</item>
<item>
<title>XSS security fix in Domino R9 HTTP server may break existing web applications</title>
<pubDate>Mon, 3 Jun 2013 21:56:04 +0200</pubDate>
<description>
<![CDATA[
Last week we noticed that two of our web applications did not work as expected after upgrading our servers to Domino R9. We tracked down the issue and found the problem: In one REST API call, we have ...
]]>
</description>
<link>https://www.mindoo.com/web/blog.nsf/dx/03.06.2013215603KLERDL.htm</link>
<category>Lotus Notes 9</category>
<dc:creator>Karsten Lehmann</dc:creator>
<comments>https://www.mindoo.com/web/blog.nsf/dx/03.06.2013215603KLERDL.htm?opendocument&comments</comments>
<guid isPermaLink="true">https://www.mindoo.com/web/blog.nsf/dx/03.06.2013215603KLERDL.htm</guid>
<content:encoded><![CDATA[ Last week we noticed that two of our web applications did not work as expected after upgrading our servers to Domino R9. We tracked down the issue and found the problem: In one REST API call, we have a query string parameter that contains a Domino fulltext query to filter the entries of a Notes view. Domino now reported that the query syntax was wrong. The same code had worked in 8.5.3. The reason is that the Domino R9 HTTP server contains a security fix to prevent applications from being vulnerable to cross site scripting attacks (XSS). IBM picked the brute force solution here: All occurences of "<" and ">" in the url automatically get replaced. "<" becomes "-lt" and ">" becomes "-gt". Let's take the following simple XPage as an example: <code><<img alt="Image:XSS security fix in Domino R9 HTTP server may break existing web applications" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/03.06.2013215603KLERDL.htm/content/M2?OpenElement" />?xml version="1.0" encoding="UTF-8"?<img alt="Image:XSS security fix in Domino R9 HTTP server may break existing web applications" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/03.06.2013215603KLERDL.htm/content/M3?OpenElement" />> <<img alt="Image:XSS security fix in Domino R9 HTTP server may break existing web applications" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/03.06.2013215603KLERDL.htm/content/M4?OpenElement" />xp:view xmlns:xp="http://www.ibm.com/xsp/core"<img alt="Image:XSS security fix in Domino R9 HTTP server may break existing web applications" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/03.06.2013215603KLERDL.htm/content/M5?OpenElement" />> Content of query parameter param1:<<img alt="Image:XSS security fix in Domino R9 HTTP server may break existing web applications" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/03.06.2013215603KLERDL.htm/content/M6?OpenElement" />xp:br<img alt="Image:XSS security fix in Domino R9 HTTP server may break existing web applications" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/03.06.2013215603KLERDL.htm/content/M7?OpenElement" />><<img alt="Image:XSS security fix in Domino R9 HTTP server may break existing web applications" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/03.06.2013215603KLERDL.htm/content/M8?OpenElement" />/xp:br<img alt="Image:XSS security fix in Domino R9 HTTP server may break existing web applications" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/03.06.2013215603KLERDL.htm/content/M9?OpenElement" />>         <<img alt="Image:XSS security fix in Domino R9 HTTP server may break existing web applications" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/03.06.2013215603KLERDL.htm/content/M10?OpenElement" />xp:inputTextarea id="inputTextarea1"                 style="width:600.0px;height:200.0px" value="#{javascript:param.param1}"<img alt="Image:XSS security fix in Domino R9 HTTP server may break existing web applications" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/03.06.2013215603KLERDL.htm/content/M11?OpenElement" />>         <<img alt="Image:XSS security fix in Domino R9 HTTP server may break existing web applications" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/03.06.2013215603KLERDL.htm/content/M12?OpenElement" />/xp:inputTextarea<img alt="Image:XSS security fix in Domino R9 HTTP server may break existing web applications" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/03.06.2013215603KLERDL.htm/content/M13?OpenElement" />> <<img alt="Image:XSS security fix in Domino R9 HTTP server may break existing web applications" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/03.06.2013215603KLERDL.htm/content/M14?OpenElement" />/xp:view<img alt="Image:XSS security fix in Domino R9 HTTP server may break existing web applications" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/03.06.2013215603KLERDL.htm/content/M15?OpenElement" />></code> When I call this XPage with a URL like http://localhost/urltest.nsf/params.xsp?param1=[date]%3E%3D01.01.2008%20AND%20[date]%3C%3D31.12.2008 we get the following result in Domino 8.5.3: <code>Content of query parameter param1: [date]>=01.01.2008 AND [date]<=31.12.2008</code> With Domino R9, we get this instead: <code>Content of query parameter param1: [date]-gt=01.01.2008 AND [date]-lt=31.12.2008</code> You can see that the operators "<" and ">" got replaced and the ft query is no longer valid. The big surprise here was that the Domino server even replaces these characters if they are correctly escaped as hex codes like %3C and %3E. This way, IBM wants to prevent web developers from writing the query string content as part of a HTML page without properly escaping "dangerous" characters, e.g. to tell the user that a passed search query "<<img alt="Image:XSS security fix in Domino R9 HTTP server may break existing web applications" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/03.06.2013215603KLERDL.htm/content/M16?OpenElement" />script type='text/javascript'<img alt="Image:XSS security fix in Domino R9 HTTP server may break existing web applications" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/03.06.2013215603KLERDL.htm/content/M17?OpenElement" />>alert('it works!');<<img alt="Image:XSS security fix in Domino R9 HTTP server may break existing web applications" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/03.06.2013215603KLERDL.htm/content/M18?OpenElement" />/script<img alt="Image:XSS security fix in Domino R9 HTTP server may break existing web applications" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/03.06.2013215603KLERDL.htm/content/M19?OpenElement" />>" is not understandable, which would immediately execute the script block in the browser and could cause a lot worse effects than just a simple alert box. And this is not a theoretical threat. <a href="http://www.wissel.net/blog/d6plinks/SHWL-8XS3MY" target=_blank>It has been done before</a>. Workarounds / solutions We asked IBM if the current implementation, which also replaces the hex encoded characters, is working as designed and they confirmed. They said they had seen too many XSS attacks in different areas of the product and customer applications, so they picked the "big hammer" as a solution. It's unlikely that this behavior will change anytime soon, but if somebody has a better idea, they are open for discussion. Here are a few things that you might try to make your application work again, if you've got the same issues: 1. Change the URL parameters In our sample, we could change the query parameters so that we only pass the min and max dates as query string arguments. The whole FT query can then get computed on the server side. Depending on the kind of query string parameter, replacing "-lt" and "-gt" with the correct values also could be an option. But this might lead into trouble if someone wants to send "-lt" or "-gt" as part of a query string parameter on purpose. 2. Use POST instead of GET If you put the ft query in the payload of a POST request, the parameters do not get replaced. 3. Disable the XSS fix (not recommended) IBM dev told us that the XSS security fix can be disabled by setting the Notes.ini variable HTTP_QUERY_STRING_SCRUB=0 Of course, then the server will be more vulnerable to XSS attacks. So use it at your own risk and try to find a better solution. ]]></content:encoded>
<wfw:commentRss> https://www.mindoo.com/web/blog.nsf/dxcomments/03.06.2013215603KLERDL.htm</wfw:commentRss>
<wfw:comment> https://www.mindoo.com/web/blog.nsf/dx/03.06.2013215603KLERDL.htm?opendocument&comments</wfw:comment>
</item>
<item>
<title>Entwicklercamp 2013 slides about "Dojo 1.8 and AMD" now available in English</title>
<pubDate>Fri, 24 May 2013 20:48:25 +0200</pubDate>
<description>
<![CDATA[
My slides about "Dojo 1.8 and AMD" are now available in English. I have updated my original blog article: My EntwicklerCamp 2013 slides: Dojo 1.8 and AMD ...
]]>
</description>
<link>https://www.mindoo.com/web/blog.nsf/dx/24.05.2013204824KLEQ3B.htm</link>
<category>Entwicklercamp 2013</category>
<dc:creator>Karsten Lehmann</dc:creator>
<comments>https://www.mindoo.com/web/blog.nsf/dx/24.05.2013204824KLEQ3B.htm?opendocument&comments</comments>
<guid isPermaLink="true">https://www.mindoo.com/web/blog.nsf/dx/24.05.2013204824KLEQ3B.htm</guid>
<content:encoded><![CDATA[ My slides about "Dojo 1.8 and AMD" are now available in English. I have updated my original blog article: <div align=center><a href="https://www.mindoo.com/web/blog.nsf/dx/13.03.2013145359KLEJBB.htm" title="13.03.2013145359KLEJBB.htm" target="_blank">My EntwicklerCamp 2013 slides: Dojo 1.8 and AMD</a></div> ]]></content:encoded>
<wfw:commentRss> https://www.mindoo.com/web/blog.nsf/dxcomments/24.05.2013204824KLEQ3B.htm</wfw:commentRss>
<wfw:comment> https://www.mindoo.com/web/blog.nsf/dx/24.05.2013204824KLEQ3B.htm?opendocument&comments</wfw:comment>
</item>
<item>
<title>My EntwicklerCamp 2013 slides: Dojo 1.8 and AMD</title>
<pubDate>Wed, 13 Mar 2013 14:53:59 +0200</pubDate>
<description>
<![CDATA[
Here are the slides for my EntwicklerCamp 2013 session about "Dojo 1.8 and AMD" in English: and in German Download archive with both versions: Slides as ZIP-Archive ...
]]>
</description>
<link>https://www.mindoo.com/web/blog.nsf/dx/13.03.2013145359KLEJBB.htm</link>
<category>Entwicklercamp 2013</category>
<dc:creator>Karsten Lehmann</dc:creator>
<comments>https://www.mindoo.com/web/blog.nsf/dx/13.03.2013145359KLEJBB.htm?opendocument&comments</comments>
<guid isPermaLink="true">https://www.mindoo.com/web/blog.nsf/dx/13.03.2013145359KLEJBB.htm</guid>
<content:encoded><![CDATA[ Here are the slides for my EntwicklerCamp 2013 session about "Dojo 1.8 and AMD" in English: <div align=center> <a href="https://www.mindoo.com/web/blog.nsf/dx//web/ec13/slides.nsf/content/index_en.html" target="_blank"><img alt="Image:My EntwicklerCamp 2013 slides: Dojo 1.8 and AMD" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/13.03.2013145359KLEJBB.htm/content/M2?OpenElement" /></a></div> and in German <div align=center><a href="https://www.mindoo.com/web/blog.nsf/dx//web/ec13/slides.nsf/content/index.html" target="_blank"><img alt="Image:My EntwicklerCamp 2013 slides: Dojo 1.8 and AMD" border="0" src="https://www.mindoo.com/web/blog.nsf/dx/13.03.2013145359KLEJBB.htm/content/M3?OpenElement" /></a></div> Download archive with both versions: <a href="https://www.mindoo.com/web/blog.nsf/dx/ec13-slides.zip/$file/ec13-slides.zip">Slides as ZIP-Archive</a> ]]></content:encoded>
<wfw:commentRss> https://www.mindoo.com/web/blog.nsf/dxcomments/13.03.2013145359KLEJBB.htm</wfw:commentRss>
<wfw:comment> https://www.mindoo.com/web/blog.nsf/dx/13.03.2013145359KLEJBB.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