Geert Bellekens

Geert Bellekens

Geert Bellekens

Bellekens IT (Consultant)
 

Bellekens IT was founded in 2004 by Geert Bellekens and has a strong focus on UML, modelling and analysis methodology.

Geert Bellekens has helped several of the larger Belgian organizations to define and document their modelling method, train and coach the modelers and develop supporting tools.

Geert Bellekens is an acknowledged Enterprise Architect expert and has written numerous add-ins for Enterprise Architect, including the free open source EA Navigator and EA-Matic.

He is also one of the founding members and a regular speaker on the EA User Group events.

pjmmjjlfefhmngjc.png

Call for Speakers and/or Teachers

Brussels
October 5 & 6, 2017

Dear Enterprise Architect enthusiast.

Our next EA User Group event is planned on the 5th and 6th October 2017 in Brussels.
Similar to the event in London in May we will organize a two-day event.

The first day, 5 October will be the training day. This day will be filled with 1/2 day hands-on training sessions to allow us to go into detail on a variety of subjects.

The second day, 6 October will be a classical EAUG day filled with 45-minute sessions covering all kinds of EA related topics.

We are interested in just about everything you do with Enterprise Architect, from the organisation of your model to enhancements you have made using MDG or the automation API, or even just a project with which you are especially happy with. That said, we are not just after the sunshine stories and would be interested in hearing about any experiences learned the hard way. Presentations of an obvious or purely commercial nature will not be accepted.

Some example topics are:

  • Enterprise Architecture (TOGAF, DoDAF/UPDM)
  • Business Architecture, Capability Mapping, Process Modelling
  • Systems Engineering
  • Business Analysis, Requirements Management
  • Modelling Languages (UML, SysML, BPMN, ArchiMate)
  • SOA, DDS, GIS, NIEM
  • Data modelling
  • Code generation/IDE integration
  • Project management
  • EA-based reporting
  • EA scripting and automation
  • Simulation
  • Tool adoption/deployment
  • MDG Technologies/UML profiles
  • Model collaboration and management
  • Test management

Do you have a story to tell or a course to teach?

If so, please let us know.

Closing date for Speaker submissions for the
Enterprise Architect Brussels Conference 2017 is
September 15, 2017

You will be confirmed as a speaker no later than September 22, 2017.
Thank you for taking time to share with us!

The Bellekens EA toolpack, the free set of add-ins for Enterprise Architect has expanded with a new add-in: the EA TFS Connector.EATFSConnectorLogo

This new add-in for Sparx Systems Enterprise Architect synchronizes workitems 2-ways between EA and TFS (Microsoft Team Foundation Server), so both from TFS to EA as from EA to TFS.

The EA TFS Connector uses the REST API web-service of TFS to synchronize items, so no local TFS (Visual Studio) installation is required, and it also works with TFS version 2015, which isn’t the case with the standard Visual Studio MDG integration.

      Special thanks goes to 
RealDolmen 
      for sponsoring the development of this add-in.

Have you tried the add-in and feel like it’s missing something? Don’t hesitate to contact me. There are always possibilities to enhance the add-in and make it better for the whole community.

For more information see EA TFS Connector.

Wednesday, 19 October 2016 04:08

New! Support Contracts with Bellekens!

support-icon

Ever needed a helping hand, or needed an expert to fall back on if you have a difficult question or face a problem with Enterprise Architect?

Now you can. Bellekens now offers support contracts for those occasional interventions.

We offer both Monthly as Yearly subscriptions depending on your needs.

Montly

You will receive a monthly invoice with all the details of the treated support tickets.

Base Base hours base hourly rate base amount extra 15 minutes **
No base* 0 € 45
1 h base 1 € 150 € 150 € 45
2 h base 2 € 140 € 280 € 45
5 h base 5 € 130 € 650 € 45
10 h base 10 € 120 € 1.200 € 45

* If you choose for the option with No base the minimum charge is 1 hour. Extra work will be charged per extra 15 minutes. So your monthly invoice can either be €0, or it will be at least € 180
The other options have a base price that will be charged every month, regardless of there was an actual support request that month or not

Yearly

You pay out front for a full year in support. In the event that the chosen plan doesn’t really fit your needs anymore we are quite flexible in changing your plan at any time.

Base Base hours price per hour base amount extra 15 minutes **
12 h base € 12 € 140 € 1.680 € 35
24 h base € 24 € 130 € 3.120 € 45
60 h base € 60 € 120 € 7.200 € 45
120 h base € 120 € 110 € 13.200 € 45

**Outside of the base hours foreseen in the support contract

For more information and singing up to the service please visit the Support page

Friday, 26 August 2016 09:47

EA Mapping tool => Who wants it?

I’m thinking about developing a mapping tool add-in for EA.
The idea is that you can manage a mapping between two types of (data) models. For example between your logical data model and your message model, or between your logical data model and your database model etc…

I already have a number of add-ins and scripts that somehow create traceability between models on element, attribute and association level, but I don’t have a tool yet to visualize and manage those traces.

To give you an idea the GUI of the thing could look similar to this:

mapping tool
Functions could include
– ability to add notes to each mapping
– ability to export the mapping to excel
– drag-n-drop to create mappings
– …
Now it seems to me like there could be many parties interested in such a tool.
I would like to develop this as a free and open source add-in (as I do for all my add-ins) but I’m still looking for sponsors.
My initial rough estimate for the development of such a tool is 15 man days.

I already have two parties that might be interested, but the more sponsors I can find the lower the price would get for each individual party.

So if you are interested in such a tool please let me know: This email address is being protected from spambots. You need JavaScript enabled to view it. and we might be able to work something out.

Github shapescript library

The new open source Enterprise Architect Shapescript Library in Github is an initiative to share shapescripts for Enterprise Architect within the user community.

Shapescripts in Enterprise Architect are used to define the presentation of elements on a diagram. They are mostly used when defining a UML profile in Enterprise Architect that extends UML or another modelling language with project specific elements and properties.

Shapescript examples

When developing UML profiles these shapescripts are stored in the _image attribute on the stereotype element, and they can be easily edited using the profile helper.

Shapescript editor

After a while however you’ll have a bunch of shapescripts scattered over different profiles, and projects, and it becomes hard to manage, or do any kind of version control. Finding a specific shapescript where you used a particular feature is next to impossible if you don’t remember exactly which stereotype this shapescript belonged to.

Exporting shapescripts

With the shapescript editor you can export each shapescript individually, but once you have more then a couple of shapescripts that quickly becomes a drag to save your shapescripts to files.

So I wrote a script called ExportAllShapeScripts that searches a repository for all stereotypes that have a shapescript, and exports all of these shapescripts in one go.

This script is part of the Enterprise-Architect-VBScript-Library. Read the article How to use the Enterprise Architect VBScript Library for instructions on downloading and using the Library in Enterprise Architect.

Running this script will save each shapescript as a textfile with extension .shapeScript, grouped in packages per profile.

Shapescripts saved

The code explained

The export script first uses an SQL query to find all shapescripts. Technically the shapescripts are stored in the default property of the attribute with the name _image. The script is stored as an xml tag Image in a zipped and base64 encoded format. A typical shapescript might look like this in the database:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<Image type="EAShapeScript 1.0" xmlns:dt="urn:schemas-microsoft-com:datatypes" dt:dt="bin.base64">
UEsDBBQAAAAIABpRIkdk2qflMQIAADIHAAAHABEAc3RyLmRhdFVUDQAHncrmVZ3K5lWdyuZV
jVXJTsMwFJxrkfiHCC5FqsRSaIsQhx44sohKcC5toUihqUjYxb8z8xw3jksLsmIn9sx43vOS
HFMMMccECZ749ogZNrGBL6sbSNn3gQwvKFg+DHmKLfZPcM+eZzIeqFGw76Tk3LPvneNj9JEb
Y8TxayoVHMmML+YLRyqWq8emmxP3ybcmuthDC222OyXS4fpEjjGgxh1rH0OTejP2PbF3whly
frewTw2puDbUcVp5kIM62437XHiPDeyy3FnkCXEuviG5D5YXjxrwvcAV6xluiR7za0qP7YUH
oa6X+E1zWzmOncdObsytcjuiSkpPqa3jZBFBgzFleDU/GcfloW1zhJqeJYxHLM8cK3VY1is5
xLJSGINW+5lo33dGDanMGYMyInYLB+hZLWddtqvUMpv9N8dNHJKnHdVZ4/hoMdtfmNhFPNdv
TmMdZSfGhNEUeAsy02eeRnYyuuZR7GPmp1U66lmODlmkKkwca91jj2zh1+XD6cQe6xjnIcbU
45gaI2Gb2c3xaSulvR/uWs9ZdX7210SjDCgPq336MxWjQqe53YXagQnPeWa3WXWWtCMLu+WE
GHE8tXiqc1tXXr4hHNKtkR7tgb8YB+U6Ca8V/R+rY7vdsTqm8B/Wsek7VpWvOi9ufXHf39bq
qd70KLvujteaPML9EbQnMvYldKF9MLQbODVGeDvXR76sTsr1uCz/RdLVf2Bgd391yyUlem44
7bq0RG7jgqfqnHfONr8qbN25f34AUEsBAhcLFAAAAAgAGlEiR2Tap+UxAgAAMgcAAAcACQAA
AAAAAAAAAACAAAAAAHN0ci5kYXRVVAUAB53K5lVQSwUGAAAAAAEAAQA+AAAAZwIAAAAA
</Image>

So the SQL selects all attributes owned by a element with stereotype «stereotype» with the name _imagethat have the tag <Image>  in their Default field.

1
2
3
4
5
6
7
8
9
'get all attributes with name _image that have shapescript in the default field and a parent with stereotype «stereotype»
dim sqlGetShapescriptAttributes
sqlGetShapescriptAttributes = "select a.ID from (t_attribute a " & _
                              " inner join t_object o on (o.Object_ID = a.Object_ID " & _
                              "                     and o.Stereotype = 'stereotype')) " & _
                              " where a.Name = '_image' " & _
                              " and a.[Default] like '<Image type=""EAShapeScript" & getWC & "'"
dim shapeScriptAttributes
set shapeScriptAttributes = getAttributesByQuery(sqlGetShapescriptAttributes)

Then we loop the schapescript attributes, decode the shapescript and save it as an individual text file.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
'loop the shape script attributes
for each shapeScriptAttribute in shapeScriptAttributes
    'get the stereotype
    dim stereotype as EA.Element
    set stereotype = Repository.GetElementByID(shapeScriptAttribute.ParentID)
    dim profile as EA.Package
    set profile = findProfilePackage(stereotype)
    'load the resultset in the xml document
    dim shapeScript
    shapeScript = decodeBase64zippedXML(shapeScriptAttribute.Default,"Image")
    if len(shapeScript) > 0 then
        dim scriptFile
        set scriptFile = New TextFile
        scriptfile.Contents = shapeScript
        'save the script
        scriptFile.FullPath = selectedFolder.FullPath & "\" & profile.Name & "\" & stereotype.Name & ".shapeScript"
        scriptFile.Save
        'debug info
        Session.Output "saving script: " & scriptFile.FullPath
    end if
next

The real difficulty in this script was to decode the shapescript, which is hidden in the method decodeBase64zippedXML  defined in the XML utility script. It first base64 decodes the contents of the tag, then saves it as a zip file, unzips the zip file, gets the text file in the zip file, and returns the contents of the text file. Then it deletes the temporary zip file and folder it was extracted to.

 Contributing

If you have shapescripts of your own that you wish to share you can send a github pull request, or an email to This email address is being protected from spambots. You need JavaScript enabled to view it..

Any bright ideas on how to document each of the shapescripts with an image of shape are welcome too.

This article was originally published at bellekens.com

The Enterprise Architect VBScript Library is an open source library of VBScripts written to be used in Enterprise Architect.

This article explains how to download, import and use the library in Enterprise Architect.

Initial Import

Initial scripts

The Enterprise Architect VBScript Library contains some scripts to load and save scripts from/to your file system, but before we can use those we have to import an initial set of scripts to get started.

After downloading the file select menu option Project|Data Management|Import Reference Data and choose the downloaded file. Make sure to select Automation scriptsand click Import.

This will import the minimum set of scripts required to load other scripts from the file system

 

 

VBScript library initial script set
VBScript library initial script set
€0.00
Download
 

Download library from GitHub

From the Enterprise Architect VBScript Library project page on GitHub you can either choose to download the library as a zip file, or download the repository in GitHub desktop.

VBScript library github

Load library into Enterprise Architect

Select scripts folderOne of the scripts in the initial set is the scriptLoadScripts in the group Script Management. If you execute this script you can choose the library folder from the library downloaded from GitHub.

The script will then scan the entire folder tree and it will load any .vbs file it can find.

For starters it might be interesting to only load the Frameworks scripts as they have the most chance of being useful to anyone.

If the LoadScripts script finds a script that already exists in Enterprise Architect it will ask to overwrite the existing scripts.

In order to know in which group the script belongs it will look for a the group indicator in the script.

1
'[group=Script Management]

This will tell the script that this script should go in the group Script Management. If the script indicator is absent it will assume the group name is the name of the folder where it was found.

After loading the scripts into EA make sure to press the refresh button to make the scripts appear in the GUI.

Refresh script tree

Saving all your scripts

In the script management group there also a script to save all your scripts to the file system.

In order to control where the script should go you can add the path indicator to the script like this

1
'[path=\Framework\Tools\Script Management]

The path indicator will control where to place the script relative to the chosen folder.

If the path indicator is absent the name of the script group will be used as name of the folder.

Being able to save and load the scripts from/to the file system now allows us to use version control on these scripts.

The library structure

The library is structured in two main parts.

  • Projects
    Contains an assortment of various scripts written for various projects.
  • Framework
    Contains the framework scripts that are meant to be used by other scripts
    • Utils
      Contains helper scripts and classes such as TextFile, SQL, XML etc..
    • Wrappers
      Contains the wrapper classes for EA elements such as TaggedValue, Script, ScriptGroup

The scripts in the projects folder can be used for inspiration, but it is mainly the scripts in the Framework part that are useful when writing scripts.

Using the library

The first thing you need to do when you want to use any of the framework classes is to include the framework in your script

1
!INC Wrappers.Include

This will include the “Include” script that takes care of including all the other scripts of the framework, including those of the Utils folder.

Then you can use the classes defined in the library. For eaxample, if you want to have the user select a directory you can use following code

1
2
3
4
'get the folder from the user
dim folder
set folder = new FileSystemFolder
set folder = folder.getUserSelectedFolder("")

The classes in the library contain both properties as operations. You can use the properties as you would expect from “real” classes.

1
2
3
4
5
'show messagebox with the name of each subfolder
dim subfolders, subfolder
for each subfolder in folder.SubFolders
    msgbox "subfolder name: " & subfolder.Name
next

Contributing

Have you written any VBScripts for Enterprise Architect you would like to share? If you would like to contribute to the Enterprise Architect VBScript library you can email me at This email address is being protected from spambots. You need JavaScript enabled to view it.

This script will search the text in the comments, scenario’s and linked document of the selected elements for terms in the domain model. If it finds a match it will create a trace from your selected element to the element in the domain model.

The idea is that when we write descriptions and scenario’s we often use terms already defined in the domain model, so it would be good if we had a real trace from the element in the domain model and the element using it in its description.

Link to domain model example

But it is hard to keep the descriptions and scenario’s in sync with the traces to the domain model. This script does the hard part for us and keeps those traces in sync. All you need to do is type your description and run the script. The script will find the referenced elements in the domain model and create a trace link to it. It will also remove any automatic traces that are not valid anymore.

Next to the NameNotes, and the Linked Document, this script will also search the scenarios, both theScenario Description, as the structured Scenario Steps. In case of a Scenario Step the script will insert to the name of the domain model element in the Uses column.Link to domain model scenario

Note that the script is case sensitive. That is the reason why RoomType does not appear in the uses column. Enterprise Architect itself isn’t that picky, and it underlines Roomtype anyway because it finds a relationship to RoomType.

In order to execute the script you have to select either one or more elements in the project browser, or select a package in the project browser.

Link to domain model menu option

Then select Script|Link To Domain Model

Free download

Trace to Domain Model script
Trace to Domain Model script
€0.00
Download

The script

In the first part we ask the user to select the domain model package.
If you want to use this script on a particular model you may want to replace that by a hard coding the Domain models GUID into the script.
Since this script may run for a while on a large model, we also create an output tab so we can inform the user of our progress.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
sub main
    'let the user select the domain model package
    dim response
    response = Msgbox ("Please select the domain model package", vbOKCancel+vbQuestion, "Selecte domain model")
    if response = vbOK then
         
        dim domainModelPackage as EA.Package
        set domainModelPackage = selectPackage()
        if not domainModelPackage is nothing then
            Repository.CreateOutputTab "Link to Domain Model"
            Repository.ClearOutput "Link to Domain Model"
            Repository.EnsureOutputVisible "Link to Domain Model"
            'link selected elements to the domain model elements
            linkSelectionToDomainModel(domainModelPackage)
            'tell the user we are done
            Repository.WriteOutput "Link to Domain Model", "Finished!", 0
        end if
    end if
end sub

Next we create a dictionary of all classes in domain model package and all of the sub-packages recursively.

1
2
3
4
5
6
7
8
'first get the pattern from all the classes in the domain model
dim dictionary
Set dictionary = CreateObject("Scripting.Dictionary")
 
'create domain model dictionary
'tell the user what we are doing
Repository.WriteOutput "Link to Domain Model", "Creating domain model dictionary", 0
addToClassDictionary domainModelPackage.PackageGUID, dictionary

Based on this dictionary we can create one large Regular Expression that will tell us which of the terms in the dictionary are used in a certain text.

1
2
3
4
5
6
7
8
9
' and prepare the regex object
dim pattern
'create the pattern based on the names in the dictionary
pattern = createRegexPattern(dictionary)
Dim regExp 
Set regExp = CreateObject("VBScript.RegExp")
regExp.Global = True  
regExp.IgnoreCase = False
regExp.Pattern = pattern

Then we check what is selected in the project browser. If the user has selected one or more elements we start process those elements. If a package is selected then we process the elements in the selected package.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
' Get the type of element selected in the Project Browser
dim treeSelectedType
treeSelectedType = Repository.GetTreeSelectedItemType()
' Either process the selected Element, or process all elements in the selected package
select case treeSelectedType
    case otElement
        ' Code for when an element is selected
        dim selectedElements as EA.Collection
        set selectedElements = Repository.GetTreeSelectedElements()
        'link the selected elements with the
        linkDomainClassesWithElements dictionary,regExp,selectedElements
    case otPackage
        ' Code for when a package is selected
        dim selectedPackage as EA.Package
        set selectedpackage = Repository.GetTreeSelectedObject()
        'link use domain classes with the elements in the selected package
        linkDomainClassesWithElementsInPackage dictionary, regExp,selectedPackage
    case else
        ' Error message
        Session.Prompt "You have to select Elements or a Package", promptOK
end select

Here’s the complete code for the script.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
option explicit
 
!INC Local Scripts.EAConstants-VBScript
 
'
' Script Name: Link to Domain Model
' Author: Geert Bellekens
' Purpose: Link elements with classes in the domain model based on their name.
' Date: 15/11/2015
'
 
 
sub main
    'let the user select the domain model package
    dim response
    response = Msgbox ("Please select the domain model package", vbOKCancel+vbQuestion, "Selecte domain model")