As I see in your code you already do some "error handling". So you can continue:

Change your code

Do objExternalUser.%Save()

to the following:

set stat=objExternalUser.%Save()

if $$$ISERR(stat) {

 #; error handling

 d $System.OBJ.DisplayError(stat)

}

HTH.

Out of curiosity - you have empty Try-Catch block. Why don't use it?

you could embrace your code into the following:

$$$TOE(objExternalUser.%Save())

And catch your error with status in catch then.

Hi Salma!

If you import this file from this Open Exchange project it can do the export classes in folders:

Once imported call this to setup a folder:

USER>do ##class(dev.code).workdir("my/workdir/src")

Call this to export all classes, macro, deepsee resources in a given workdir.

USER> do ##class(dev.code).export()

You also can import the whole package too.

HTH

Hi Ed!

One of the ways to expand the functionality in DeepSeeWeb is to expand the library of DSW widgets. 

The standard way is to implement the needed functionality in javascript (or take the one which already does what you want from the Internet) and make use of this javascript-widget as a new one with portlets.

Then introduce a new class derived from Portlet class (e.g. SmartMarkersPortlet) into the namespace and make sure that the name of the javascript file is equal to a classname.

Make sure to put the js file into /addons folder of dsw.

Then add the new SmartMarkerPortlet on a dashboard, provide the datasource and work with it as with usual widget.

Check how htmlViewer addon is implemented as an example.

Hi @Sourabh Sethi !

The LinkedIn page is nice! 

But I can advise for InterSystems Developer along with videos one of the best ways to highlight the skills for large audience is DC page with a set of articles with InterSystems experience (e.g. this one or that one) and OpenExchange page with a set of projects and solutions on InterSystems technologies like this, that or another one.

It's all about multi-model nature of IRIS and Caché.

Everything in Caché and InterSystems IRIS is being stored in globals - key-value sparse stored arrays.

Every persistent class (a class which stores data on disk) has the map of how the data should be stored in a particular global (globals).

ObjectScript Class definition provides the API of how the data will be stored and read from a global (globals) via Object Script or SQL access.

You can specify standard or custom storage strategy for a class. 

The persistent 'SomeClass' class with standard storage strategy will provide the API to store data in ^SomeClassD data for data itself and ^SomeClassI global for indexes.

You can see the storage strategy of a class in the source code of a persistent class immediately after successful compilation - it will be visible in a related XML block at the bottom of the class.

In your case you have a custom storage strategy which could be everything. Check @Brendan Bannon's series on that which could be really helpful for you.

As @Eduard Lebedyuk mentioned, if you delete the class as source code (e.g. via Management Portal)  it will not delete the data itself.

But! As @Robert Cemper mentioned if you delete it via SQL API with DROP statement it will delete data in a global too (because we suppose the data to be deleted if we DROP a table, right?).

HTH

Hi Stella!

This is complicated cause the base class of a cube should contain the most granular records for the subject area being analyzed. Speaking with family terms children can analyze their dads in a cube but not vice versa.  That means want to analyze Kids - build the cube for Kids.

There is one trick though which lets you analyze Kids from Dads assuming if your Dad is not very fruitful ;) I mean this will work if your Dad has less then 1,000 kids) 

You can build the Kids dimension with a level which consists of a comma-separated list of Kids IDs or kids data - use ObjectScript expressions for this. And mark this dimension as comma-separated in Dimension settings.

If the ObjectScript expression is long, use %cube.Method to call the method of the cube where you can code the complex logic.

Then you are able to show in levels and properties in this dimension whatever data you want to calculate and aggregate from kids using ObjectScript expressions.

HTH

Hi Scott!

First, thanks for mentioning Open Exchange, I appreciate :) Here is the link of Sysmon Dashboards on OEX.

Also, here is the article by @Semen.Makarov, which could help.

The tool just visualizes the data you have %SYSMONMGR, I believe the utility appeared at early versions of Caché.

The visualization is better with DeepSee Web, this will require at least Caché 2014 for REST and JSON.

Also I'll ping @Daniel Kutac for more details who initially introduced the tool

Hi Yaniv!

As @Chris Thompson mentioned you can use DSTIME for automatic records changes tracking which will be stored in a special global. But I doubt if it works for classes with non-standard storage schema just by adding DSTIME=auto;

How do you add/update records in your application? You need to introduce special calls in your "create/update" procedures to track changes. DSTIME=auto; does exactly same adding "tracking" logic in SQL and Object requests for class changes. Maybe you can use some calls with DSTIME=manual; mode.

@Alexander Koblov  do you know if it is possible to use DSTIME somehow in this case?

Another approach which may work in your case is to use AUDIT to track the changes users made to DB and then analyze this data, e.g. like here. But I never did it for non-standard storage schema.

Hi, Stefan!

In this situation, I would suggest using RELEASES approach for different InterSystems Data Platforms. E.g. you can generate XML release package from the code base in git and then replace all the specific places for a given version on a build release phase. As a result you will have different XML packages for Ensemble and for InterSystems IRIS and have one code base, say in IRIS.

For example, you can see that approach @Eduard Lebedyuk used for RESTForms distribution. There are 2016.1 and 2016.2 release packages which can be installed in 2016.1 and 2016.2+ Caché or Ensemble versions respectfully.

To simplify release building I can recommend ISC.DEV utility which can export a release or patch file(upon git commits) for a given mask of classes.

HTH