FAQ

Yes. With the exception of some components like:

Some additional configuration is required though.

You need to add some init-parameters to WEB.XML within the TVC Servlet definition. The init parameters are defined as below:

Following table shows the parameters you need, and some description:

There is no automated process for this, it has to be done manually.

Yes.

This can be done in a couple of different ways, see explanation below:

Add init parameters to the tvc-servlet within "web.xml" like the example below:

This alternative is sometimes not OK as you store the password within the web.xml file in clear text.

Instead you can do:

The role/group assignment to a person is cached in TVC in order to reduce the need for accessing the DB to get this information. Clearing the TVC Cache will of course clear this info, however, it will also clear everything that doesn’t need to be cleared.

A better alternative is to use the below methods:

Or, use this method:

Alternatively, you can also do this for all persons by using one of the two alternatives below:

Or,

The first call is fast, while the latter will take some time as it needs to reload the cache for all persons.

The "core" class in TVC that does the name lookup is called com.technia.tvc.core.db.aef.naming.Naming

This method has a couple of methods for resolving symbolic names. All these are cached after first retrieval (until the TVC cache is cleared). The drawback with these methods (on the Naming class) is that those requires a "Transactional Context" to be allocated.

These classes serves different purposes.

SymbolicName is a wrapper class around the "Naming" and it represents a single symbolic-name / resolved-name value.

The SymbolicName caches the resolved value and sub-sequent retrieval of the value does not require transactional context to be available. Normally, the SymbolicName is used as "static final" fields in a class/interface:

One can provide a default value as the second argument, in order to use this value if the name-lookup fails for some reason.

To get the real name, simply do:

The ParsedStatement is typically used to define select statements containing symbolic names. For example:

To get the real select statement, one simply do:

It works in a similar way as SymbolicName; e.g. the parsing is done once only.

The rule for both SymbolicName and ParsedStatement is that these should be used as static-final fields. If used as field in a method, it’s advantage is less as the parsing will be done more than one time for the same expression.

No. TVC is not dependent on any class within the AEF/BPS nor any central (except for some data model specific code, which exists in our XBOM Manager and ECO/ECR Manager components).

The only dependency TVC has, is against the ENOVIA-ADK classes.

Also, the TVC caches are better and more intelligent. The ENOVIA caches are loaded on server startup, which is the reason why the first login takes huge amount of time.

TVC caches are loaded on demand.

The TVC installation adds commands to a menu called “Admin Tools”, including the “Clear TVC Cache” command. But this depends on that menu (menu_AEFAdminToolsMenu) existing.

If, for some reason, that’s not there (due to access, or other reasons), it can be done manually by using this URL:

No, Top Panel is inplemented to update directly (same as the Structure Browser)

Basically, the columns are created by the so called TableFactory. You can specify your own factory via parameter:

Implement the table factory:

Extend TableFactory to implement loadTable. You can create a configurable table using a normal table definition as template and dynamically add columns to that definition.

In short:

Detailed:

When the user wants to perform an action (such as invoking a command from the context-menu or the tool-bar), the action typically applies to the selectedrows in the structure browser.

In order to instruct the Structure Browser to include these selected rows in the request when calling the action, one need to set the "Submit" setting on the command to TRUE. Note: In case you use XML commands/menus, the tag is called <SubmitForm>.

This implies that all the selected rows are submitted under the request parameter "emxTableRowId" (same as used in the centrals). The format of this parameter is:

In case when the row(s) only has information about the object

In case when the row(s) has information about both a connection and object

This format was introduced in TVC 2009.1.0 in order to improve compatibility with AEF (or BPS) as they include the parent object-id also.

This format will be used in case when you submit from a strucuture page

If you set the "Submit OID" setting to true, the id of the object used to launch the structure browser with, will be included in the request. That id will be passed using the "objectId" request parameter.

The reason why we don’t submit this always, is that some commands work in the way to first check the "objectId" parameter and if not found check the "emxTableRowId" parameter. If we always would pass "objectId", those commands would start to behave wrongly.

Yes. This is achieved by implementing a so called "TableModel" or "TreeTableModel" (similar to what’s in the javax.swing world).

Depending on the model used; one will need to use different actions (URLs):

And

Where "producer" is a request parameter holding a class name.

The table-model producer interface is defined like:

The tree-table-model producer interface is defined like:

The TableModel and TreeTableModel interfaces are defined in the following packages:

Look for AbstractTableModel, SimpleTableModel and AbstractTreeTableModel in the Java Docs available in TVC Developer docs.

No, this is not configurable today. The target table-bean is a "clone" of the table-bean that you start the build-structure from.

We however do some changes to the cloned copy, such as changing the header/sub-header and modifying some properties on the "Page Config" instance.

If you want to customize this; then you have to do some (minor) coding:

Create an action class that is derived from the base class

Maybe call this com.acme.actions.CustomBuildStructureAction

Add a mapping to this action class within your own "Action mapping" file (never change the one in the component) Define this like the example below:

Finally, overload the method getTargetTable(HttpServletRequest) like below:

Since a pageconfig can have multiple views with multiple tables, it rely upon column settings instead of using an href parameter (as used by the ENOVIA tables); it would be difficult to define default sort column for all tables in all views using just request parameters. To use, add the Sort Direction setting to the column that you would like to sort on by default; if you have multiple columns that should be sorted on, also use the Sort Order setting to define the order of the sort.

Note that SB will remember which columns a user sorted on and auto apply these on the next visit, so the default sort settings will typically only apply for your first visit to a page, after that it will use the sort order from the personalization data.

Remembering column sorting and column visibility on user level can be globally switched on/off using the following init parameter to the tvc-servlet in the "web.xml":

The default value is true.

It’s also possible to control this on a pageconfig level by adding the "selectionTracking" parameter:

The global setting in combination with the setting per pageconfig decide whether user selections should be remembered or not.

Add the postprocess expandAll parameter to your pageconfig parameters or command URL

The reason below is that you are using a custom datahandler. The default datahandler usually takes care of the editable program invocation. My suggestion is that you add the editable logic directly to the custom datahandler or invoke the JPO from there.

This feature is only available for right click context menus. For toolbar actions you need to handle this in the action (and notify user?).

Try using a selection behaviour to update values in bean. Then use bean values rather than request parameters in your actions.

No it is not supported.

TVC has a built in logic to prevent memory leakage problems from double clicks in the category tree. The problem occurs as structure browser table beans are loaded into session but never removed as the forward to the jsp registering the onunload event is never rendered because of the new request.

If you have any problems with the functionality you can turn it off using the init parameter

The renderer of the whole form is not possible to customize right now, but it might be something we will consider to allow in the future

To make the form forward to your own jsp, you can specify a custom processor for the form, and override the getForward() method, which is responsible for specifying where to forward after the form has been processed. Add the element <Processor>JAVACLASS</Processor>, pointing to a java class extending in this case the CreateObject class, since it’s a create form, and implementing the getForward method.

I’m creating “Create And Connect” Form but I have problems in it.

I was wondering if I’m able call TVC CreateAndConnect Form using Schema Command object? My problem is that it’s calling this form alright but for some reason it’s not connecting newly created object to object where call is made from.

_For some reason it seems that it’s not passing parent object id to CreateAndConnect Form. _

Maybe you’re just missing this:

TVC Forms have support for processors. A processor is what contains the main logic for whatever the result of the form should be. In the case of create forms, there is a processor used that simply creates objects and sets the attributes and basics for it.

If some special logic, such as a custom name generator, is needed when creating objects, it is possible to create your own form processor:

The specified class must extend from the class com.technia.tvc.structurebrowser.form.process.FormProcessor.

Here is a simple example:

No.

Also: We are not developing gvis charts any more so do not expect this in the future. Please use jqplot implementation instead as that is the api that we are adding functionality for.

The name is legacy, and originates from TVC Report Generator 3.0 (2003).

The conversion properties is a multiline attribute on the report-definition object.

The original idea was that this attribute will hold properties/settings that controls the data-conversion, but the scope of this attribute has grown and is used for many purposes. Example:

Yes.

The purpose with data handlers is to create "Cell" and populate these with value(s) (a Cell can have multiple CellValue’s associated). The report generator produces output according to what the cell’s on a row contains, and this typically looks like:

Note that a value in a cell can be associated with a different object, which in turn results in that the oid/rid/type attribute is added.

The value itself is escaped by default, as the value might contain characters that causes the XML data to be invalid. If you want to populate a cell with vaules that represents XML data, you can do this by applying the setting:

The value that is being added, is retrieved from the method "getDisplayValue" on the CellValue instance.

In many cases, it is very useful to implement a datahandler that produces XML data, for reference see Report Generator Data Handler Example on how to implement such a datahandler in the report generator.

As usual, you have a number of alternatives to choose from:

The original idea with the TVC Report Generator was to generate XML over a set of objects by using a table (or system table) and convert this XML into some other format using a so called converter. The most famous examples are:

Convert the raw XML to XSL-FO and use FOP to produce for example PDF from the XSL-FO

Convert the raw XML to HTML directly (either creating a HTML report, or a HTML page that Excel can interpret)

The good thing with XML/XSLT is that you can modularize the report and reuse pieces like tables, datahandlers, inquiries etc and only spend time on developing the stylesheets.

If you want to create reports without the influence of XML/XSLT, then you need to do slightly more coding than you otherwise would have needed. In some cases, the time of doing that is shorter than developing stylesheets but sometimes not.

Anyhow, what you are looking for is achieved by implementing a so called Custom Report, which uses a custom Java class for producing the report. Please look at the FAQ Custom Report Example for details.

Again, this approach requires you to implement data-extraction etc. Of course, you can utilize the TVC API to load inquiries, performing expansions and evaluate a table over a flat-list or structure.

An alternative, which somehow requires you to parse XML, is to use a custom converter.

This class should implement this interface:

It has one method that needs to be implemented, and some skeleton code is shown below:

Depending on what output you create, you need to set this on the report as well:

What you can do here, if you need more advanced logic for creating the groups, is to create a column with a datahandler in the table used for the report.

Include the grouping/formatting logic in this column so that the result is the grouping you need. Then use that column to group, and just hide it from the rest of the report (in the stylesheet, just skip that column).

You can use the Custom report. Depending on what output you want, you need to specify what converter to be used.

This example assumes that you will produce XSl-FO with your stylesheet and use a compatible output format (PDF for example):

Again, use the Custom Report as base. IText is part of the TVC-Core, so you don’t need any additional JARs for this.

See this example:

You need to point out the webapp directory using the environment variable TVC_WEBAPP_DIR

Skeleton class for custom reports.

The name of the class is com.technia.tvc.reportgenerator.datahandler.AttributesHandler

The synchronization feature is there, but not on XBL type baselines, only on the original XBOM, i e manufacturing or engineering baselines.

Add the following tag to your "main page"

It is included inside the jar file. (You can open the jar file using 7zip)