Em Workflows, há um recurso particularmente poderoso e complexo Ação chamado Campos Calculados , que permite fazer operações nos valores dos registros que você está manipulando.
Adicionando parâmetros #
É possível adicionar parâmetros às fórmulas usando o menu suspenso na seção Parâmetros da interface do usuário do Calcular Campos. A lista suspensa contém todos os campos (básicos e personalizados) que pertencem ao módulo selecionado na seção de campos básicos.
Para adicionar um parâmetro, selecione o campo na lista suspensa e clique em Adicionar parâmetro. Após esta ação, uma nova linha aparece na tabela de parâmetros com o nome do campo e o identificador fornecido.
Para alguns campos (dropdowns e multisseleções) um dropdown adicional é exibido onde o usuário pode selecionar se o valor bruto ou formatado deve ser usado em Campos Calculados. O formato bruto significa o valor armazenado no banco de dados e o valor formatado significa o rótulo desse valor do banco de dados.
Para remover um parâmetro da tabela, basta clicar no botão– na linha do parâmetro. Esteja ciente de que, se você remover um parâmetro, todos os identificadores serão recalculados, portanto, os identificadores podem ser alterados para campos!
O identificador é usado para referenciar este campo quando o usuário cria a fórmula. Por exemplo, todas as aparências do identificador {P0} serão substituídas pelo nome da conta na fórmula. Todos os parâmetros são como {Px} onde x é a ordem sequencial do parâmetro. A quantidade dos parâmetros não é limitada.
Adicionando parâmetros de relação #
Os parâmetros de relação são muito semelhantes aos parâmetros regulares, a única diferença é que o usuário primeiro seleciona uma entidade que está em um relacionamento um-para-um ou um-para-muitos com a entidade real.
Para adicionar um parâmetro de relação, selecione primeiro a relação e, em seguida, selecione o campo da entidade conectada e pressione o botão Adicionar parâmetro de relação. Após esta ação, uma nova linha aparece na tabela de parâmetros da relação com o nome da relação, o nome do campo e o identificador fornecido.
Quanto aos parâmetros para alguns campos de parâmetros de relação (dropdowns e multi-seleções), um dropdown adicional é exibido onde o usuário pode selecionar se o valor bruto ou formatado deve ser usado em Calcular Campos.
Para remover um parâmetro de relação da tabela, basta clicar no botão– botão na linha do parâmetro de relação. Esteja ciente de que, se você remover um parâmetro de relação, todos os identificadores serão recalculados, portanto, os identificadores podem ser alterados para campos!
O identificador é usado para referenciar este campo quando o usuário cria a fórmula. Por exemplo, todas as aparências do identificador {R0} serão substituídas pelo nome de usuário do usuário criador na fórmula. Todos os parâmetros de relação são como {Rx} onde x é a ordem sequencial do parâmetro de relação. A quantidade de parâmetros de relação não é limitada.
Criando fórmula para um campo #
Na parte Fórmulas da interface do usuário, o usuário pode adicionar fórmulas para campos da entidade real.
Para adicionar uma fórmula, selecione primeiro um campo na lista suspensa e, em seguida, pressione o botão Adicionar fórmula. Após esta ação, uma nova linha aparece na tabela de fórmulas com o nome do campo e com o local da fórmula.
Para remover uma fórmula da tabela, basta clicar no botão–na linha da fórmula.
A fórmula é uma caixa de texto onde o usuário pode escrever as fórmulas. O módulo avalia a fórmula no tempo determinado (ao salvar, ao executar o agendador ou ambos) e preenche o campo selecionado com o valor avaliado.
A fórmula pode conter qualquer texto (com suporte total a UTF-8), mas apenas as partes da função (funções com parâmetros entre ‘{‘ e ‘}’) são avaliadas. Por exemplo e com os parâmetros adicionados nas seções anteriores, se preenchermos a fórmula como: Conta {P0} criada por nome de usuário {R0}, o campo de descrição terá o seguinte valor após salvar: Conta Minha conta criada por nome de usuário MyUser (implicando que o nome da conta é My Account e o nome de usuário do usuário criador é MyUser).
O Calcular Campos possui muitas funções integradas que permitem ao usuário construir fórmulas complexas para atingir vários objetivos. Essas funções são descritas na próxima seção.
Funções disponíveis #
Como mencionado acima, todas as funções são agrupadas entre sinais { e }, e elas se parecem com{functionName(parameter1; parameter2; …)}. A contagem dos parâmetros é diferente para as diferentes funções. O módulo avalia as funções e as altera com seu resultado na fórmula.
As funções podem ser embutidas umas nas outras (usando o resultado de uma função como parâmetro para outra função) como neste exemplo:
{power({subtract({divide({add({multiply(10; 2)}; 12)}; 8)}; 1)}; 2)}
Esta função é a aparência formalizada da seguinte expressão matemática:
((((10 * 2) + 12) / 8) – 1)2
As funções estão divididas em seis grupos. Esses grupos são descritos na próxima seção do documento.
Funções lógicas #
As funções lógicas estão retornando true ou false na forma de 1 e 0, portanto, os campos digitados nas caixas de seleção podem ser preenchidos com essas funções. Eles também podem ser usados como condição lógica para a função ifThenElse.
equal #
| Signature | {equal(parameter1;parameter2)} |
| Parameters | parameter1: can be any value of any type |
| parameter2: can be any value of any type | |
| Description | Determines if parameter1 equals with parameter2 |
| Returns | 1 if the two parameters are equal or 0 if not |
| Example call | {equal(1; 2)} returns 0 |
notEqual #
| Signature | {notEqual(parameter1; parameter2)} |
| Parameters | parameter1: can be any value of any type |
| parameter2: can be any value of any type | |
| Description | Determines if parameter1 not equals with parameter2 |
| Returns | 0 if the two parameters are equal or 1 if not |
| Example call | {notEqual(1; 2)} returns 1 |
greaterThan #
| Signature | {greaterThan(parameter1; parameter2)} |
| Parameters | parameter1: can be any value of any type |
| parameter2: can be any value of any type | |
| Description | Determines if parameter1 greater than parameter2 |
| Returns | 1 if parameter1 greater than parameter2, 0 if not |
| Example call | {greaterThan(3; 3)} returns 0 |
greaterThanOrEqual #
| Signature | {greaterThanOrEqual(parameter1; parameter2)} |
| Parameters | parameter1: can be any value of any type |
| parameter2: can be any value of any type | |
| Description | Determines if parameter1 greater than or equal parameter2 |
| Returns | 1 if parameter1 greater than or equal parameter2, 0 if not |
| Example call | {greaterThanOrEqual(3; 3)} returns 1 |
lessThan #
| Signature | {lessThan(parameter1; parameter2)} |
| Parameters | parameter1: can be any value of any type |
| parameter2: can be any value of any type | |
| Description | Determines if parameter1 less than parameter2 |
| Returns | 1 if parameter1 less than parameter2, 0 if not |
| Example call | {lessThan(3; 3)} returns 0 |
lessThanOrEqual #
| Signature | {lessThanOrEqual(parameter1; parameter2)} |
| Parameters | parameter1: can be any value of any type |
| parameter2: can be any value of any type | |
| Description | Determines if parameter1 less than or equal parameter2 |
| Returns | 1 if parameter1 less than or equal parameter2, 0 if not |
| Example call | {lessThanOrEqual(3; 3)} returns 1 |
empty #
| Signature | {empty(parameter)} |
| Parameters | parameter: text value |
| Description | Determines if parameter is empty |
| Returns | 1 if parameter is empty, 0 if not |
| Example call | {empty(any text)} returns 0 |
notEmpty #
| Signature | {notEmpty(parameter)} |
| Parameters | parameter: text value |
| Description | Determines if parameter is not empty |
| Returns | 1 if parameter is not empty, 0 if empty |
| Example call | {notEmpty(any text)} returns 1 |
not #
| Signature | {not(parameter)} |
| Parameters | parameter: logical value |
| Description | Negates the logical value of the parameter |
| Returns | 1 if parameter is 0, 0 if parameter is 1 |
| Example call | {not(0)} returns 1 |
and #
| Signature | {and(parameter1; parameter2)} |
| Parameters | parameter1: logical value |
| parameter2: logical value | |
| Description | Applies the AND logical operator to two logical values |
| Returns | 1 if parameter1 and parameter2 is 1, 0 if any parameters are 0 |
| Example call | {and(1; 0)} returns 0 |
or #
| Signature | {or(parameter1; parameter2)} |
| Parameters | parameter1: logical value |
| parameter2: logical value | |
| Description | Applies the OR logical operator to two logical values |
| Returns | 1 if parameter1 or parameter2 is 1, 0 if both parameters are 0 |
| Example call | {or(1; 0)} returns 1 |
Funções de texto #
As funções de texto são usadas para manipular o texto de várias maneiras. Todas as funções listadas aqui são totalmente compatíveis com textos UTF-8, portanto, caracteres especiais não devem causar problemas.
substring #
| Signature | {substring(text; start; length)} |
| Parameters | text: text value |
| start: decimal value | |
| length [optional parameter]: decimal value | |
| Description | Cuts the substring of a text field from start. If the length optional parameter is not set, then it cuts all characters until the end of the string, otherwise cuts the provided length. Indexing of a text’s characters starting from 0. |
| Returns | Substring of the given text |
| Example call | {substring(This is my text; 5)} returns is my text |
| {substring(This is my text; 5; 5)} returns is my |
length #
| Signature | {length(parameter)} |
| Parameters | parameter: text value |
| Description | Count the characters in a text. |
| Returns | The count of the characters in a text. |
| Example call | {length(sample text)} returns 11 |
replace #
| Signature | {replace(search; replace; subject)} |
| Parameters | search: text value |
| replace: text value | |
| subject: text value | |
| Description | Replace all occurrences of search to replace in the text subject. |
| Returns | subject with replaced values. |
| Example call | {replace(apple; orange; This is an apple tree)} returns This is an orange tree |
position #
| Signature | {position(subject; search)} |
| Parameters | subject: text value |
| search: text value | |
| Description | Find position of first occurrence of search in a subject |
| Returns | Numeric position of search in subject or -1 if search not present in subject |
| Example call | {position(Where is my text?; text)} returns 12 |
lowercase #
| Signature | {lowercase(parameter)} |
| Parameters | parameter: text value |
| Description | Make text lowercase |
| Returns | The lowercased text. |
| Example call | {lowercase(ThIs iS a sAmPlE tExT)} returns this is a sample text |
uppercase #
| Signature | {uppercase(parameter)} |
| Parameters | parameter: text value |
| Description | Make text uppercase |
| Returns | The uppercased text. |
| Example call | {uppercase(ThIs iS a sAmPlE tExT)} returns THIS IS A SAMPLE TEXT |
Funções matemáticas #
Funções matemáticas são usadas para manipular números de várias maneiras. Vários operadores matemáticos são implementados como funções em Calcular Campos.
add #
| Signature | {add(parameter1; parameter2)} |
| Parameters | parameter1: number value |
| parameter2: number value | |
| Description | Adds parameter1 and parameter2 |
| Returns | The sum of parameter1 and parameter2 |
| Example call | {add(3.12; 4.83)} returns 7.95 |
subtract #
| Signature | {subtract(parameter1; parameter2)} |
| Parameters | parameter1: number value |
| parameter2: number value | |
| Description | Subtracts parameter2 from parameter1 |
| Returns | The distinction of parameter2 and parameter1 |
| Example call | {subtract(8; 3)} returns 5 |
multiply #
| Signature | {multiply(parameter1; parameter2)} |
| Parameters | parameter1: number value |
| parameter2: number value | |
| Description | Multiplies parameter1 and parameter2 |
| Returns | The product of parameter1 and parameter2 |
| Example call | {multiply(2; 4)} returns 8 |
divide #
| Signature | {divide(parameter1; parameter2)} |
| Parameters | parameter1: number value |
| parameter2: number value | |
| Description | Divides parameter2 with parameter1 |
| Returns | The division of parameter2 and parameter1 |
| Example call | {divide(8; 2)} returns 4 |
power #
| Signature | {power(parameter1; parameter2)} |
| Parameters | parameter1: number value |
| parameter2: number value | |
| Description | Raises parameter1 to the power of parameter2 |
| Returns | parameter1 raised to the power of parameter2 |
| Example call | {power(2; 7)} returns 128 |
squareRoot #
| Signature | {squareRoot(parameter)} |
| Parameters | parameter: number value |
| Description | Calculates the square root of parameter |
| Returns | The square root of parameter |
| Example call | {squareRoot(4)} returns 2 |
absolute #
| Signature | {absolute(parameter)} |
| Parameters | parameter: number value |
| Description | Calculates the absolute value of parameter |
| Returns | The absolute value of parameter |
| Example call | {absolute(-4)} returns 4 |
Funções de data #
Existem várias funções de data implementadas em Calcular Campos, para que o usuário possa manipular as datas de várias maneiras. A maioria das funções usa um parâmetro de formato, que é usado para definir o resultado das funções formatadas como o usuário deseja. As opções para esses formatos são equivalentes aos parâmetros de formato PHP:
| Format character | Description | Example returned values |
|---|---|---|
| For day | ||
| d | Day of the month, 2 digits with leading zeros | 01 to 31 |
| D | A textual representation of a day, three letters | Mon through Sun |
| j | Day of the month without leading zeros | 1 to 31 |
| l | A full textual representation of the day of the week | Sunday through Saturday |
| N | ISO-8601 numeric representation of the day of the week | 1 (for Monday) through 7 (for Sunday) |
| S | English ordinal suffix for the day of the month, 2 characters | st, nd, rd or th. Works well with j |
| w | Numeric representation of the day of the week | 0 (for Sunday) through 6 (for Saturday) |
| z | The day of the year (starting from 0) | 0 through 365 |
| For week | ||
| W | ISO-8601 week number of year, weeks starting on Monday | 42 (the 42nd week in the year) |
| For month | ||
| F | A full textual representation of a month, such as January or March | January through December |
| m | Numeric representation of a month, with leading zeros | 01 through 12 |
| M | A short textual representation of a month, three letters | Jan through Dec |
| n | Numeric representation of a month, without leading zeros | 1 through 12 |
| t | Number of days in the given month | 28 through 31 |
| For year | ||
| L | Whether it’s a leap year | 1 if it is a leap year, 0 otherwise |
| o | ISO-8601 year number. This has the same value as Y, except that if the ISO week number (W) belongs to the previous or next year, that year is used instead | 1999 or 2003 |
| Y | A full numeric representation of a year, 4 digits | 1999 or 2003 |
| y | A two digit representation of a year | 99 or 03 |
| For time | ||
| a | Lowercase Ante meridiem and Post meridiem | am or pm |
| A | Uppercase Ante meridiem and Post meridiem | AM or PM |
| B | Swatch Internet time | 000 through 999 |
| g | 12-hour format of an hour without leading zeros | 1 through 12 |
| G | 24-hour format of an hour without leading zeros | 0 through 23 |
| h | 12-hour format of an hour with leading zeros | 01 through 12 |
| H | 24-hour format of an hour with leading zeros | 00 through 23 |
| i | Minutes with leading zeros | 00 to 59 |
| s | Seconds, with leading zeros | 00 through 59 |
| For timezone | ||
| e | Timezone identifier | UTC, GMT, Atlantic/Azores |
| l | Whether or not the date is in daylight saving time | 1 if Daylight Saving Time, 0 otherwise |
| O | Difference to Greenwich time (GMT) in hours | +0200 |
| P | Difference to Greenwich time (GMT) with colon between hours and minutes | +02:00 |
| T | Timezone abbreviation | EST, MDT |
| Z | Timezone offset in seconds. The offset for timezones west of UTC is always negative, and for those east of UTC is always positive. | -43200 through 50400 |
| For full date/time | ||
| c | ISO 8601 date | 2004-02-12T15:19:21+00:00 |
| r | RFC 2822 formatted date | Thu, 21 Dec 2000 16:01:07 +0200 |
| U | Seconds since the Unix Epoch (January 1 1970 00:00:00 GMT) |
Para todas as funções sem parâmetro timestamp, assumimos que a data/hora atual é 2016.04.29. 15:08:03
date #
| Signature | {date(format; timestamp)} |
| Parameters | format: format text |
| timestamp: date/time value | |
| Description | Creates a date in the given format |
| Returns | timestamp in the given format |
| Example call | {date(ymd; 2016-02-11)} returns 160211 |
now #
| Signature | {now(format)} |
| Parameters | format: format text |
| Description | Creates the actual date/time in the given format |
| Returns | Current date/time in the given format |
| Example call | {now(Y-m-d H:i:s)} returns 2016-04-29 15:08:03 |
yesterday #
| Signature | {yesterday(format)} |
| Parameters | format: format text |
| Description | Creates yesterday’s date/time in the given format |
| Returns | Yesterday’s date/time in the given format |
| Example call | {yesterday(Y-m-d H:i:s)} returns 2016-04-28 15:08:03 |
tomorrow #
| Signature | {tomorrow(format)} |
| Parameters | format: format text |
| Description | Creates tomorrow’s date/time in the given format |
| Returns | Tomorrow’s date/time in the given format |
| Example call | {tomorrow(Y-m-d H:i:s)} returns 2016-04-30 15:08:03 |
datediff #
| Signature | {datediff(timestamp1; timestamp2; unit)} |
| Parameters | timestamp1: date/time value |
| timestamp2: date/time value | |
| unit: years/months/days/hours/minutes/seconds; default: days | |
| Description | Subtracts timestamp2 from timestamp1 |
| Returns | The difference between the two dates returned in unit |
| Example call | {datediff(2016-02-01; 2016-04-22; days)} returns 81 |
addYears #
| Signature | {addYears(format; timestamp; amount)} |
| Parameters | format: format text |
| timestamp: date/time value | |
| amount: decimal number | |
| Description | Adds amount years to timestamp |
| Returns | Incremented date in format |
| Example call | {addYears(Ymd; 2016-04-22; 1)} returns 20170422 |
addMonths #
| Signature | {addMonths(format; timestamp; amount)} |
| Parameters | format: format text |
| timestamp: date/time value | |
| amount: decimal number | |
| Description | Adds amount months to timestamp |
| Returns | Incremented date in format |
| Example call | {addMonths(Ymd; 2016-04-22; 1)} returns 20160522 |
addDays #
| Signature | {addDays(format; timestamp; amount)} |
| Parameters | format: format text |
| timestamp: date/time value | |
| amount: decimal number | |
| Description | Adds amount days to timestamp |
| Returns | Incremented date in format |
| Example call | {addDays(Ymd; 2016-04-22; 1)} returns 20160423 |
addHours #
| Signature | {addHours(format; timestamp; amount)} |
| Parameters | format: format text |
| timestamp: date/time value | |
| amount: decimal number | |
| Description | Adds amount hours to timestamp |
| Returns | Incremented date in format |
| Example call | {addHours(Ymd H:i:s; 2016-04-22 23:30; 5)} returns 20160423 04:30:00 |
addMinutes #
| Signature | {addMinutes(format; timestamp; amount)} |
| Parameters | format: format text |
| timestamp: date/time value | amount: decimal number |
| Description | Adds amount minutes to timestamp |
| Returns | Incremented date in format |
| Example call | {addMinutes(Ymd H:i:s; 2016-04-22 22:58; 5)} returns 20160422 23:03:00 |
addSeconds #
| Signature | {addSeconds(format; timestamp; amount)} |
| Parameters | format: format text |
| timestamp: date/time value | |
| amount: decimal number | |
| Description | Adds amount seconds to timestamp |
| Returns | Incremented date in format |
| Example call | {addSeconds(Ymd H:i:s; 2016-04-22 22:58; 5)} returns 20160422 22:58:05 |
subtractYears #
| Signature | {subtractYears(format; timestamp; amount)} |
| Parameters | format: format text |
| timestamp: date/time value | |
| amount: decimal number | |
| Description | Subtracts amount years from timestamp |
| Returns | Decremented date in format |
| Example call | {subtractYears(Ymd; 2016-04-22; 5)} returns 20110422 |
subtractMonths #
| Signature | {subtractMonths(format; timestamp; amount)} |
| Parameters | format: format text |
| timestamp: date/time value | |
| amount: decimal number | |
| Description | Subtracts amount months from timestamp |
| Returns | Decremented date in format |
| Example call | {subtractMonths(Ymd; 2016-04-22; 5)} returns 20151122 |
subtractDays #
| Signature | {subtractDays(format; timestamp; amount)} |
| Parameters | format: format text |
| timestamp: date/time value | |
| amount: decimal number | |
| Description | Subtracts amount days from timestamp |
| Returns | Decremented date in format |
| Example call | {subtractDays(Ymd; 2016-04-22; 5)} returns 20160417 |
subtractHours #
| Signature | {subtractHours(format; timestamp; amount)} |
| Parameters | format: format text |
| timestamp: date/time value | |
| amount: decimal number | |
| Description | Subtracts mount hours from timestamp |
| Returns | Decremented date in format |
| Example call | {subtractHours(Ymd H:i:s; 2016-04-22 12:37; 5)} returns 20160422 07:37:00 |
subtractMinutes #
| Signature | {subtractMinutes(format; timestamp; amount)} |
| Parameters | format: format text |
| timestamp: date/time value | |
| amount: decimal number | |
| Description | Subtracts amount minutes from timestamp |
| Returns | Decremented date in format |
| Example call | {subtractMinutes(Ymd H:i:s; 2016-04-22 12:37; 5)} returns 20160422 12:32:00 |
subtractSeconds #
| Signature | {subtractSeconds(format; timestamp; amount)} |
| Parameters | format: format text |
| timestamp: date/time value | amount: decimal number |
| Description | Subtracts amount minutes from timestamp |
| Returns | Decremented date in format |
| Example call | {subtractSeconds(Ymd H:i:s; 2016-04-22 12:37; 5)} returns 20160422 12:36:55 |
Funções de controle #
Há apenas uma função de controle implementada em Calcular Campos até agora, mas essa função garante que o usuário possa escrever fórmulas muito complexas com condições. Como as funções podem ser embutidas umas nas outras, o usuário pode escrever junções com muitas ramificações.
ifThenElse #
| Signature | {ifThenElse(condition; trueBranch; falseBranch)} |
| Parameters | condition: logical value |
| trueBranch: any expression | |
| falseBranch: any expression | |
| Description | Selects one of the two branches depending on condition |
| Returns | trueBranch if condition is true, falseBranch otherwise |
| Example call | {ifThenElse(\{equal(1; 1)}; 1 equals 1; 1 not equals 1)} returns 1 equals 1 |
Contadores #
Existem vários contadores implementados em Calcular Campos que podem ser usados em vários cenários.
Os contadores classificados em dois grupos:
- Contadores globais: contadores que são incrementados toda vez que uma fórmula afetada é avaliada
- Contadores diários: contadores que reiniciam todos os dias. (a partir de 1)
Neste capítulo, assumimos que o valor atual dos contadores é 4, portanto, o valor incrementado será 5 com o formato fornecido.
GlobalCounter #
| Signature | {GlobalCounter(name; numberLength)} |
| Parameters | name: any text |
| numberLength: decimal number | |
| Description | Increments and returns the counter for name with length numberLength |
| Returns | Counter with length numberLength |
| Example call | {GlobalCounter(myName; 4)} returns 0005 |
GlobalCounterPerUser #
| Signature | {GlobalCounterPerUser(name; numberLength)} |
| Parameters | name: any text |
| numberLength: decimal number | |
| Description | Increments and returns the counter for name for the user who creates the entity with length numberLength |
| Returns | Counter with length numberLength |
| Example call | {GlobalCounterPerUser(myName; 3)} returns 005 |
GlobalCounterPerModule #
| Signature | {GlobalCounterPerModule(name; numberLength)} |
| Parameters | name: any text |
| numberLength: decimal number | |
| Description | Increments and returns the counter for name for the module of the entity with length numberLength |
| Returns | Counter with length numberLength |
| Example call | {GlobalCounterPerModule(myName; 2)} returns 05 |
GlobalCounterPerUserPerModule #
| Signature | {GlobalCounterPerUserPerModule(name; numberLength)} |
| Parameters | name: any text |
| numberLength: decimal number | |
| Description | Increments and returns the counter for name for the user who creates the entity and for the module of the entity with length numberLength |
| Returns | Counter with length numberLength |
| Example call | {GlobalCounterPerUserPerModule(myName; 1)} returns 5 |
DailyCounter #
| Signature | {DailyCounter(name; numberLength)} |
| Parameters | name: any text |
| numberLength: decimal number | |
| Description | Increments and returns the counter for name with length numberLength |
| Returns | Counter with length numberLength, or if the counter is not incremented this day then 1 with length numberLength |
| Example call | {DailyCounter(myName; 1)} returns 5 |
DailyCounterPerUser #
| Signature | {DailyCounterPerUser(name; numberLength)} |
| Parameters | name: any text |
| numberLength: decimal number | Description |
| Increments and returns the counter for name for the user who creates the entity with length numberLength | Returns |
| Counter with length numberLength, or if the counter is not incremented this day for this user then 1 with length numberLength | Example call |
DailyCounterPerModule #
| Signature | {DailyCounterPerModule(name; numberLength)} |
| Parameters | name: any text |
| numberLength: decimal number | |
| Description | Increments and returns the counter for name for the module of the entity with length numberLength |
| Returns | Counter with length numberLength, or if the counter is not incremented this day for this module then 1 with length numberLength |
| Example call | {DailyCounterPerModule(myName; 1)} returns 5 |
DailyCounterPerUserPerModule #
| Signature | {DailyCounterPerUserPerModule(name; numberLength)} |
| Parameters | name: any text |
| numberLength: decimal number | |
| Description | Increments and returns the counter for name for the user who creates the entity and for the module of the entity with length numberLength |
| Returns | Counter with length numberLength, or if the counter is not incremented this day for the user who creates the entity and for this module then 1 with length numberLength |
| Example call | {DailyCounterPerUserPerModule(myName; 1)} returns 5 |
Exemplo – Calcular a taxa mensal de uma oportunidade #
Caso de uso #
O usuário gostaria de calcular uma taxa mensal de uma oportunidade para um campo personalizado dividindo o valor da oportunidade pela duração.
Configurar #
Nosso módulo de oportunidades possui um campo suspenso chamado Duração com valores: (valor do banco de dados entre parênteses) 6 meses [6], 1 ano [12], 2 anos [24]. Há também um campo de moeda chamado Mensal.
Fluxo de trabalho #
Vá para o módulo Workflow e crie um novo Workflow. Defina as opções básicas como a seguir:
| Nome: como você deseja | Módulo de fluxo de trabalho: oportunidades |
| Estado: Ativo | Executar: Somente ao salvar |
| Executar em: Todos os registros | Execuções repetidas: marcada |
Não criamos nenhuma condição, pois gostaríamos que o Workflow fosse executado em todas as oportunidades.
Agora, adicione uma ação e selecione Calcular campos no menu suspenso.
Em seguida, adicione dois campos de Oportunidades como parâmetros. Primeiro, selecione Valor da oportunidade (valor) e adicione-o como parâmetro (será {P0}), depois selecione Duração e a opção de valor bruto no menu suspenso de tipo de dados e adicione-o como parâmetro dois (será {P1}). Não há necessidade de adicionar parâmetros relacionais para esta fórmula.
Agora, adicione uma fórmula para o campo mensal e preencha a caixa de texto com a seguinte fórmula:
{divide({P0}; {P1})}
Portanto, toda a ação deve ficar assim:
Salve o fluxo de trabalho e crie uma nova oportunidade:
Como você pode ver, nem adicionamos o campo mensal ao EditView, pois não queremos forçar o usuário a fazer cálculos. Salve a Oportunidade e verifique os resultados no DetailView:
Campos Calculados AOW foi contribuído pordiligente tecnologia e consultoria de negócios GmbH
Removendo ações #
Você pode remover linhas de ação clicando noxno lado superior direito da Ação.
Removendo Linhas de Campo e de Relacionamento #
Você pode remover linhas de campo e de relacionamento clicando no botão– no lado esquerdo da Ação.
