Hello and welcome to an overview of Integration Studio. Integration Studio is
bundled with the OutSystems Development suite.
It allows you to create extensions to the OutSystems platform through the
creation of custom adapters that integrate with existing systems,
databases or custom code. Integration Studio has its own module format that is
called an extension module and that's where developers can build their
adapters that are then published to the OutSystems server, thus making whatever
functionality your extension has available to the normal modules.
Integration Studio's UI is very uncluttered as you can see on the right
hand side of the slide, and it essentially boils down to the extension's
content tree on the left, where you can add new elements by right-clicking, and
the element details section on the right hand side where you can then define the
properties of the selected element. Let's look into two of the most common
scenarios whereby you will want to use Integration Studio to produce an
extension. One scenario is importing external database tables to be used in
your application as entities. The second scenario is writing custom native code
that you will be able to use on your application as actions. The process of
importing external database tables is very simple:
First, someone will need to declare and detail a database connection inside
Service Center. This is not normally the role of the developer but rather of the
systems' administrator. The administrator only needs to do this setup once during
the configuration of the environment. Then the developer needs to create an
extension inside Integration Studio, connect to the OutSystems server where this
database connection has been setup and import the desired tables that are
available there. You might want to tweak certain characteristics of the imported
models, for example fine-tuning data types that were inferred wrongly or add
descriptions to the entities and attributes that will be
created. it's important to note that these imported external tables don't get
their data copied in any shape or form to the local database. In runtime, you'll
actually be querying directly over the database connection that was defined. So
the steps inside Integration Studio are: you start the wizard, you pick the
database and inside which tables you're interested in, they appear in integration
studio and you can tweak any of the properties of the imported model and
upon publishing on the server they become visible to your modules. Writing
custom native code is also a breeze.
You just need to create the extension module in Integration Studio and define
whatever actions together with their inputs and outputs that you will want to
write code for. Then, Integration Studio will generate code stubs and the project
for you to write using the proper visual environment for the dedicated language.
So for the .NET stack of the OutSystems platform you will use Visual Studio
while for the Java stack of the OutSystems platform you will use Eclipse.
It's important to note that you won't be able to call the Java code from a
Microsoft server. Once you finish writing your code using the IDE, the extension
will be compiled together with any dependencies that you've added to the
project and it will be published into the server, ready to be available to
Service Studio modules. Of course you're not limited to writing all of the code
yourself. For example, if you purchase a third-party assembly, you'll be able to
call it from this custom code and use this procedure to include this external
resource into your project. Again the steps are very simple. You start by
defining the prototypes of the actions and the underlying structures that you
will need to call from your modules. Then you will generate the project that will
open on the IDE of the target stack. There, you will flesh out the
generated stubs and upon publishing the extension to the server this
functionality becomes available to your applications. The way to consume any of
these functionalities from an extension is similar to the way you've consumed
resources from other modules: via the Manage Dependencies dialogue in Service
Studio. And that's Integration Studio in a nutshell. See you in the next lesson.