1.

Pick the sentence that describes an appropriate reason to use an expand inline parameter in an advanced query

To inject parts of the query, as long as EncodeSql is not used to avoid SQL injection
Para injetar partes da consulta, desde que EncodeSql não é usado para evitar injeção SQL

To set the parameter as optional, preventing any clause using it to be inserted in the generated SQL
Para definir o parâmetro como opcional, evitando que qualquer cláusula que o utilize seja inserida no SQL gerado

To Implement optional search parameters, by injecting the query condition with only the required clauses

To avoid SQL injection that could otherwise be explored with a normal parameter
Para evitar a injeção SQL que poderia ser explorada com um parâmetro normal
2. Pick a correct statement about the behavior that is implemented by the following relationships among entities.

Customers with Orders are not deletable and deleting an Order Line deletes the associated Order

Deleting an Order leaves the associated Order History entries but some Orders are not deletable

Referential integrity is guaranteed between Order and Order Lines and Customers with Orders are not deletable

Deleting an order deletes all associated Order Lines and referential integrity is only guaranteed between Orders and Customers
3. A Site property is a good choice to store a global parameter that is changed regularly, as long as it has a simple type.

I agree, because site properties avoids the use of configuration tables for values that change regularly
Concordo, porque as propriedades do site evitam o uso de tabelas de configuração para valores que mudam regularmente

I don't agree. Changing site properties requires invalidating the eSpace cache, which is not efficient.

I don't agree. Site properties can be used with values of simple and complex data types.
Eu não concordo. As propriedades do site podem ser usadas com valores de tipos de dados simples e complexos

I agree. The change of a site property value is only done in the cache, making it a very fast operation.
Concordo. A alteração de um valor de propriedade do site é feita apenas no cache, tornando-se uma operação muito rápida.
4. Given the following Entity Diagram, which index for JobApplication would you create to ensure that the same candidate does not apply to
the same job position twice?

( Alternative #2 )
5. Consider the need to provide a mobile interface over the Expenses application. Select the correct option:

Create a Mobile Application and, using the references to the actions and data model of the Expenses app, build the screens for the mobile
interface.

Create a Mobile Web Flow in the Expenses app with the mobile screens, reusing the data model, actions and theme already defined in
there.
Crie um Fluxo de Web Móvel na aplicação Despesas com as ecrans móveis, reutilizando o modelo de dados, as ações e o tema já
definidos.

Create a native app in Service Studio for the target device and reference the data model and actions from the Expenses application.
Crie uma aplicação nativo no Service Studio para o dispositivo de destino e faça referência ao modelo de dados e ações da aplicação
Despesas.

Create a Mobile Application that reuses the screens from the Expenses app and apply to these referenced screens the mobile theme of
the new app.
Crie uma aplicação para mobile que reutilize os ecrans da aplicação Despesas e aplique a esses ecrans referenciadas o tema móvel da
nova aplicação.
6. What is the security behavior expected with the following configuration?

 Both screens are only accessible from the Internal Network, as defined in the Configuration Tool;
 Screen Candidate_Edit validates the credentials of the Windows user, requesting them from the Browser. If the credentials don't
exist or fail to identify the user, an automatic prompt will request the credentials;
 Screen Candidates is only accessible if the user doesn't have windows credentials.

 The entire flow can't ever be accessed from outside the local network where the Application Server is;
 Screen Candidate_Edit is only accessible with windows authentication;
 Screen Candidates is accessible without windows authentication.

None of these behaviors

 Both screens are only accessible from the Internal Network, as defined in the Configuration Tool;
 Screen Candidate_Edit validate the credentials of the Windows user, requesting them from the Browser. If the credentials don't
exist or fail to identify the user, an automatic prompt will request the credentials;
 Screen Candidates is accessible without windows credentials.
7. Regarding Roles, choose the correct option:

 System role Registered is granted to any authenticated user

 Web Screens and Human Activities can be associated to Roles at run time

 Roles are used to design your security policies and associate them with eSpace elements and end-users
 Roles can only be associated to users through the Users application

 A role defined in one eSpace can be used in another eSpace

 When eSpace MyApp is created, system role MyAppUser is automatically created and can't be deleted

 eSpace elements that can be associated to Roles, include Web Screens and Human Activities
 Applications can use GrantRole and RevokeRole actions to manage role association to users
8. In the design of a process flow, an Automatic Activity is defined by

An action flow that has no output parameters

An asynchronous action that doesn't require the process execution to wait for its termination

A human activity with no user assigned

None of these definitions

9. The solution on the left presents two front-end applications (appA and appB) and a core component (coreC) that abstracts some reusable service.
Knowing that the dependencies are due to the fact that appA provides a reusable business concept that is required by coreC and that some logic around
that concept is implemented in appB, pick the best alternative and justification to correct this architecture with wrong dependencies

Alternative 2, because it's the only one that solves the circular dependencies

Alternative 2, because it creates more core components

Alternative 1, because it is less granular

Alternative 1, because correctly isolates the reusable service from appA and appB to the new core component coreAB
10. The query GetOrderLinesByOrderId is defined in the preparation of a screen. Assuming the values to calculate the VAT do not change meantime,
comment this two alternative implementations for a screen action in this screen.

They only do the same if, on second solution, the refresh query action is replaced by a copy of the original query.

The first solution is better because it caches the result of the preparation query in the viewstate.

They both do the same, but the first solution is more efficient because avoids executing the same query again.

The second solution is more efficient because decreases page size.

11. A good way to avoid recalculating large information (e.g.: 40KB) that is session dependent, is to perform the calculation only once during session
login and store the result in a session variable for future reference during the user session

I agree. Session variables should only be used to hold data that is persistent during the session

I don't agree. Session variables should only be used to hold data that change during the session

I agree. Caching large data in session variables will speed up all the screens that repeatadly require the same information

I don't agree. Since session variables are fetched and update between the Platform Server and the Platform Database in each request, it is
not recommended to hold large information.
12. Isolating a highly reusable Simple query in a User action is always a good recommendation.

I don't agree because it promotes abstraction

I agree, because it will reduce maintenance effort by only having one place to update.

I don't agree because it hides information

I don't agree because it will prevent query optimization based on used fields and most of the times not all fields of the output record
definition are used.
13. The following action is associated to a timer that is launched programmatically. It generates Traffic lines by processing Highway readings previously
placed in a temporary table. At the end the temporary table must be cleared to avoid processing the same readings in future runs of the timer.

Given the huge volume of Readings, the timeout is normally reached and new Readings keep piling up in the temporary table while no Traffic lines are
produced.

Pick the approach that avoids timeouts and ensures that the timer processes all readings and doesn't repeat work.

Cycle a configurable portion (batch) of Readings, process them and commit them. Keep processing new batches controlling the elapsed
time and wake the timer if the timeout is about to be reached.

Control the execution time of the timer, and stop iterating as soon as the timeout is about to be reached.

Get only 1000 readings on each timer run, and make sure to only delete the same readings at the end.

Inside each iteration, commit each Traffic creation and delete each reading.
14. When trying to speed up a slow screen, one should

Avoid as much as possible any processing of query results in the preparation, delaying it to the write operations.

Store information gathered in the preparation in session variables

Avoid complex advanced queries in the preparation that can be replaced by a cycle with efficient simple queries

Pre-process as much as possible during the preparation to speed operations on screens actions
15. Choose the correct option for the scenario below:
The Local eSpace was updated by admin after jff published the Foreign eSpace so a merge is really necessary in this case.

Double-clicking on BackOfficeFlow will show two Web Flow canvas side by side with no differences.

The Test CalculateStatistics action was deleted on the Foreign eSpace.

Selecting the Question_AnswersByFrequency action will merge the changes in the action flow and keep the input parameters and local
variables of the local version.
16. An Employee listing, fed by a Simple Query, is showing 5 out of 30 fields of Employee entity.
You need to implement a screen for an info balloon that shows an employee Resumed CV (field with up to 1024 chars) on mouse over the employee name.
How would you define the info balloon screen parameters?

Using Alternative 3, passing only the entity identifier to reduce the request size

Using Alternative 1, since I already got the ResumedCV on my listing query

Using Alternative 2, to avoid querying the employee again and allowing future display of other fields

None of these alternatives. I would rather create a special structure with EmployeeId and ResumedCV to type the screen input,
minimizing the number of fields passed
17. A possible measure to prevent users tampering with URL parameters is:
Use Method Submit instead of Navigate to use an HTTP POST, hence hiding the parameters from the Browser URL.

Log activity to audit who is trying to access unauthorized information.

Registro de atividade para verificar quem está tentando acessar informações não autorizadas.

Use session variables to hide sensible parameters.

Utilize variáveis de sessão para ocultar parâmetros sensíveis.

Set HTTP security to "SSL" to ensure that parameters show encrypted in the URL.
Defina a segurança HTTP como "SSL" para garantir que os parâmetros sejam criptografados na URL.
18. Comment the implementation of Concat action, that is found in an extension. The Java version is very similar.

public void MssConcat(RLMyEntityRecordList ssrecordList, out string ssText) {

ssText = string.Empty;
try {
ssrecordList.StartIteration();
while (!ssrecordList.Eof) {
ssText += ssrecordList.CurrentRec.ssSTMyEntity.ssName + ",";
ssrecordList.Advance();
}
} finally {
ssrecordList.EndIteration();
}
}

The action fills a Record List passed as an output parameter, from the beginning of the list and resets the iterator at the end of the cycle or
when an error occurs.

Exceptions during the iteration are handled by the extension.

The action iterates a Record List received as an input parameter, from the beginning of the list and resets the iterator at the end of the
cycle or when an error occurs.

Structure MyEntity is defined in Service Studio.

19. The following advanced query tries to select only required fields. Advise the best action, considering performance optimization

Select all the attributes using "Select {Question}.*, {Question_Locale}.*" to avoid run time errors

Create a specific output structure with the 3 required fields to avoid useless data retrieval

Create a special data base view that performs this query, only returning the required fields

No need to change. This query only produces a warning in Service Studio, not generating run time errors or performance issues
20. Identify characteristics of the following scenario.

Publishing a solution will loop forever, since there is a chain reaction caused by circular dependencies

Publishing a changed version of appA.oml does not force to republish coreC.oml, since this eSpace doesn't depends on appA.oml

Publishing a solution is the only way to publish all the eSpaces without outdated compilation warnings

There is no circular dependency since there is no eSpace consuming one of its consumers and hence publishing a solution is not
compromised and maintaining each eSpace is an isolated operation
21. I have a large javascript code, that defines some functions, used in one of my most frequently accessed pages. Where should I place that code?

This code should be placed as the return of a function, to allow isolation and future reuse by simply calling that function inside a screen
unescaped expression

Expanded directly in a screen unescaped expression, since this code is used only in one place

In the Web Screen JavaScript because it allows browser caching and the code is only used in this page

Place it in the eSpace JavaScript, to allow reuse and because it is the only place that allows browser caching
22. Action LoadTraffics, is called in a Screen Action and processes a large Excel file with Traffic Readings and inserts calculated entries in Traffic table,
according to the car weight, entry toll and exit toll. This implementation is very inefficient due to the amount of readings (around 50K in average)
and number of queries made in each iteration, often resulting in timeout and lost of computational effort.
Select the alternative that will address both efficiency and prevent timeouts.

Asynchronously process the readings and transform the three queries inside the cycle into a single cachable query that given the Entry
and Exit Tolls (without the weight as input), returns the Car Journey Price, reusing the result for traffics with similar journeys

Place the readings in a temporary table and let a timer with timeout management asynchronously process the readings.
Factor GetTollIn and GetTollOut in a single cache-able action to reuse the result.

Given that GetTollIn and GetTollOut are similar queries, create an auxiliary cache-able action to leverage the duplicate chances to reuse
the same results during the entire processing.

Cache all the queries so that the request doesn't timeout

23. Consider the following code snippets that implement a data bootstrap from an excel file. This implementation successfully imports all the information contained
in the excel file. Which of the following options is correct?

 The widget CompaniesExcel in Snippet #3 maps the data in the excel file to the Company entity.
 Company_Create (which calls entity action CreateCompany) is not defined in the same eSpace.

 Whenever published, the bootstrap updates the Company and Contact data.
 Company entity is exposed as read only.

 When the eSpace is published for the first time, data for the Company and Contact entities is bootstrapped.
 Since there's no GetCountryByName query in Snippet #3, CountryId field is left blank.

 In Snippet #3 a function is used in the Assign CompanyRecord node.

 Company_Create (which calls entity action CreateCompany) is not defined in the same eSpace.
24. To build a Multilingual application, after adding Locales to the eSpace, you need to:

 Add a table to manage all the language dependent resources, including Screen titles, Header captions or Button labels;
 Use the built-in action GetCurrentLocale to retrieve the correct values.

 Use the translation editor to translate all text for each Locale: text, labels, titles, entity records;
 Use the built-in actions SetCurrentLocale and GetCurrentLocale to manage the Locale in User sessions.

 Use the built-in action GetCurrentLocale to get the translation of a particular language resource;
 Use the built-in action SetCurrentLocale to dynamically change the translation of a particular language resource.

 Use the translation editor to translate language resources for each Locale;
 Extend entities with a detail entity to translate language dependent fields, and adapt queries accordingly.
25. The following action processes an Excel file with Traffic Readings and inserts entries inTraffic table. This process fails constantly due to errors on
the Excel file that result in missing elements in tables. What improvement ensures that all the correct readings are stored and the wrong ones are ignored,
without aborting the entire operation.

Check queries GetTollIn and GetTollOut and if one of them is empty, skip current reading.

Place the code inside the cycle in a auxiliary action which traps exceptions without aborting the transaction

Place all the readings in a temporary table and then call a timer to asynchronously process those readings with the same cycle
implementation

Simply place an Error Handler inside LoadTraffic to prevent the transaction to be aborted.
26. Consider you have a Contact_List (screen A) that opens a single contact on a popup,Contact_Popup_Edit (screen B) to edit or to delete that
contact. To have the least impact possible on performance only the row of the selected contact is updated on the contact list screen. The same popup is
also used to create a new contact.

Select the correct option that implements this pattern.

On screen B use the Popup_Editor_Notify action to notify screen A. On the callback in screen A refresh the query on the preparation
and refresh the TableRecords.

On screen B use the Popup_Editor_Notify action to send to screen A the operation that was executed (creation, update or deletion). On
the callback in screen A refresh the query in the preparation and then use the NotifyWidgetGetMessage() to determine the operation and
act accordingly, i.e. refresh the entire table, refresh the current row or remove the row using the ListRemove action.

On screen B use the NotifyWidget action to notify the parent and according to the message sent update the screen, i.e. refresh the entire
table if a contact is created, refresh the current row of the TableRecords if the record is updated or use ListRemove action to remove the
current row of the TableRecords if the contact is deleted.

On screen B use the Popup_Editor_Notify action to send to screen A the updated record. Update the current row of the TableRecords
with the record returned by the NotifyWidgetGetMessage() action. If the Popup_Editor_Notify action returns an empty record
use ListRemove action to remove the current row of the TableRecords.
27. Consider a table with a high growth rate where only a small percentage of the data is heavily used, but the application is forced to keep the rest of the
information for auditing and legal reasons, despite of being rarely accessed. What is the best approach to avoid deteriorating the operations on that table?

Create indexes by the most common access criteria (e.g. creation date) to speed up the most common operations

Have a database script to manually clean old records whenever you need to recover space or speed up your operations

Have a regular timer that deletes old information due to its rare use

Have a regular timer that moves the information to an archive table (preferably on a different database) and implement special screens or
Union queries that can afford to be less efficient due to the rare access to historical information.
28. Pick the sentence that better describes a static entity.

A static entity is an entity whose attributes are multi-tenant literal values.

A static entity is an entity whose attribute data types are limited to simple data types or references to other static entities.

A static entity is an entity to define literal values with attributes limited to Id, Label, Order and Is_Active.

A static entity is an entity that can only hold literal values.

29. In a multi-developer environment, if one needs to test/debug its own updates without affecting other developers of the same eSpace, the best way is to

Agree time slots for each developer to publish and test, and use Service Center Version Control and Service Studio Compare and
Merge to keep collaborative work synchronized

Run and Debug in the Personal area to avoid updates on the Public Area. Merge at the end when everyone is finished his/her individual
changes.

Clone the eSpace, work on it and merge back once fully tested

1-Click Publish to update changes, and then debug in the personal area to avoid interfering with debugging sessions of other developers
30. Caching all preparation queries, screens and webblocks will always improve web response. Comment please.

Partially agree. Caching should be restricted to the most frequently used elements and avoided whenever repeated use doesn't yield the
same result or input parameters varies a lot

Partially agree. Caching is pointless when used on intranet applications, because local access is fast enough to boost web requests

Don't agree. Caching should always be avoided because every time a change to the information is required, it will either take longer to be
available or cache must be invalidated

Totally agree. Caching elements ensure that the server spends fewer resources and clients get faster responses.
31. Consider the action MoveHistory that moves the OrderHistory from one order to another.

Pick the best consideration.

The first solution is the best, because this is a bulk update on a single attribute

The second solution is the best, because it is more built to change and UpdateOrderHistory is always optimized to update only the
changed attributes

The first solution is the only one that works

Avoid the first solution, because adding new attributes to OrderHistory will produce runtime errors, not detectable by Service Studio
32. The use of a local Web Service instead of a public action is ...

... admissible to avoid strong coupling and simplify dependencies.

... never admissible, since consuming an action is more efficient.

... only admissible when you need to serve external systems.

... recommended since it promotes loose coupling.

33. Regarding Web Services, which option is correct?

A Web Service method can be set as Internal Access Only.

Web Services can be implemented with SSL security but only with client certificates.

A Web Service method can be implemented the same way as a User action but Structures must be used for the output.

In the consumers perspective, executing a referenced User Action or a Web Service Method, that implement the same logic, is different
in terms of transactions and output structures.
34. A Process may be launched

automatically on any entity record creation or update.

automatically when an entity record, of an entity exposing process events, is created.

only explicitly in an action flow.

either automatically when an entity record is created, or explicitly in an action flow, as long as the eSpace is User Provider.
35. The image below shows the Import Entities from Database Wizard from Integration Studio.
In the previous 3 steps of the wizard, the developer selected the Northwind catalog from a database connection.
Select the only applicable option for this scenario.

Once the extension is published, you can query these entities and even join them with entities defined in Service Studio.

The wizard shows tables and views of the selected catalog on the Available Tables list, and it's possible to select the Tables to
import shown in the image with only 2 levels of related tables.

The Platform creates the OrderDetails entity with a primary key over the OrderID and ProductID attributes.

The developer must map unsupported database data types and establish the relationships between the imported entities.
36. If you need to join an entity in your eSpace with another one from a linked server (consumed from an extension), that has thousands of records, what
are your considerations?

It's recomended, because the table in the linked server is completely loaded to the DB Server before the join is performed

Instead of doing the join, query the entities separately and than cycle trough the results to correlate records

Use additional logic to pull the minimum subset of data required from the linked server (temporary tables, OPENQUERY, ...) before
performing the join

It is not possible to make cross joins over linked servers

37. Multi-tenancy allows the implementation of a solution for different user domains, supported by a single Application Server and Database Server, by:

Defining which entities are multi-tenant and setting in all queries the tenant identifier
Definindo quais entidades são multi-tenant e definindo em todas as consultas o identificador do inquilino

Isolating data, end-users, sessions and asynchronous processes per tenant

Allowing to restrict a user session (logged-in with a unique username and a secret password) to access only information associated with
all the tenants in which the user is registered
Permitir restringir uma sessão de utilizador (logon com um nome de utilizador exclusivo e uma senha secreta) para acessar apenas as
informações associadas a todos os inquilinos nos quais o utilizador está registrado

Isolating the information in multiple catalogs and deploying a different instance of the application for each Tenant
Isolando as informações em vários catálogos e implantando uma instância diferente do aplicativo para cada inquilino
38. Regarding Web References, which option is correct?

When using cache, all actions of the same Web Reference need to have the same expiration timeout.

If the Web Service is deleted or changed, when publishing an eSpace that contains a Web Reference, Service Studio displays a warning.

If the Web Service is deleted or changed, when publishing an eSpace that contains a Web Reference, Service Studio displays an error and
does not publish.

Both the Web Reference action and the screen actions that invoke it, use the same transaction.
39. Taking into account the database connection defined in Service Center, and shown below, choose the correct option:
Foreign Entities are imported with relationships, but it is not possible to execute a query that joins them.

When publishing the pubs extension, the Platform associates the Extension with the Other DB database connection.

The pubs extension uses this connection to import Foreign Entities. When using these entities in Service Studio you need to manually
take care of the transactions.

Foreign Entities without primary key are imported but only have the Create Entity Action.
40. We need to register questions for an Exam. Each question can have an image and be translated to several predefined languages.
Pick the best DB model to capture this requirement.

Scenario 3, because translations are indexed by static entity Locale and applications benefit from strong typing

Scenario 2 and 3 are the same. There's no point in isolating binary content since the platform optimizes the Simple Queries guaranteeing
that the binary fields are not returned from the database.

Scenario 2, because binary content is isolated, translations are indexed by an enumerated set of values and common info is factored

Scenario 1, because there is only one image and several translations. A simple Text code is enough to distinguish translation locales
12. When designing your data model it is possible to define indexes for the entities.
Except from one, all the options below are true. Identify the option that it's not valid.

Indexes can be unique or not, and you can use unique indexes to model composite keys.

Indexes are used by the database engine to provide faster access to the rows of the entity.

Service Studio automatically creates indexes for the foreign key attributes that you can't delete or edit.

You can create as many indexes as you like assuming the relevant trade-off between inserting and fetching data.
7. Taking into account the query presented below, what would happen if we added a new attribute to the Question_Locale entity, right after the
Id attribute, and changed the QuestionWithLocale structure accordingly?
The first publish of the application in a new environment will result in runtime errors.

We would only get runtime errors if we use SELECT * instead of SELECT locale.*.

The query could result in runtime errors because we are using an alias with a wildcard.

TrueChange™ will ensure that the query does not produce runtime errors.