Expressões de Lógica Dinâmica

Este guia explica como escrever e usar expressões com o mecanismo de Lógica Dinâmica do Fluid.

As expressões de Lógica Dinâmica são usadas em todo o Fluid para calcular valores, avaliar regras e orientar comportamentos como verificações de governança, campos calculados, automação e lógica condicional.

Este artigo explica os conceitos fundamentais, a sintaxe e os padrões comuns, com exemplos práticos que você pode reutilizar.

Uma expressão de Lógica Dinâmica é uma pequena fórmula que é avaliada em relação a um contexto, ou seja, um conjunto de campos e valores nomeados disponíveis no momento em que a expressão é executada.

As expressões são usadas em todo o Fluid para calcular valores, avaliar regras e orientar comportamentos condicionais. Elas são comumente usadas para:

• Calcular o valor de propriedades personalizadas (por exemplo, derivar uma pontuação, status ou categoria em um formulário)

• Aplicar regras de negócio e lógica de governança com base em dados de projetos ou cartões

• Categorizar dados usando limites ou condições (por exemplo, faixas de risco ou intervalos de duração)

• Controlar resultados em automação e lógica de fluxo de trabalho

• Derivar valores de datas, números e campos de texto sem atualizações manuais

Uma expressão pode:

• Comparar valores

• Combinar texto

• Realizar operações aritméticas

• Tomar decisões (usando IF ou CASE)

• Trabalhar com datas (por exemplo, durações e categorização)

As expressões são avaliadas dinamicamente, o que significa que o resultado é atualizado automaticamente sempre que os dados subjacentes mudam.

Os valores de campo são referenciados usando colchetes:

[FieldName]

Os nomes de campo não diferenciam maiúsculas de minúsculas.

As expressões podem referenciar tanto propriedades de primeira classe (como atributos de projeto) quanto propriedades personalizadas. As propriedades personalizadas são expostas usando múltiplos formatos de referência.

Para uma propriedade personalizada com a chave Score e o rótulo Priority Score, as seguintes referências estão disponíveis:

[Score] // key name

[Priority Score] // label name

[_Score] //Underscore alias to the key name

Usar o alias com sublinhado (por exemplo [_Score]) é recomendado porque:

• Deixa imediatamente claro que o valor vem de uma propriedade personalizada

• Reduz o risco de conflitos de nomes com campos padrão (de primeira classe)

• Melhora a legibilidade em expressões mais longas ou complexas

Onde houver qualquer risco de ambiguidade ou conflito, o alias com sublinhado fornece a referência mais previsível e de fácil manutenção.

+ - * / %

= <> < <= > >=

AND OR NOT

( ... )

A concatenação de strings usa +.
Se qualquer um dos lados for não numérico, o resultado é tratado como texto.

[Tier] + "-" + [_RiskLevel]

Use IF para uma única decisão sim/não.

IF(condition, whenTrue, whenFalse)

Exemplo:

IF([Tier] = "Gold", "Premium", "Standard")

Use CASE quando você tiver múltiplas condições ordenadas.

CASE(
  condition1, result1,
  condition2, result2,
  ...
  defaultResult
)

Exemplo:

CASE(
  [Prop.Score] >= 90, "Gold",
  [Prop.Score] >= 80, "Silver",
  "Bronze"
)

As condições são avaliadas de cima para baixo, e a primeira correspondência é retornada.

COALESCE retorna o primeiro valor não nulo e não vazio.

COALESCE([Missing], [Tier], "Unknown")

Esta é a forma recomendada de lidar com campos opcionais de forma segura.

Determina se um determinado termo de pesquisa (term) aparece em uma string alvo (value). Retorna um booleano (TRUE / FALSE).

Sintaxe:

CONTAINS(value, term, {case insensitive}, {whole word match})

• value (obrigatório): O texto a ser pesquisado.

• term (obrigatório): O termo de pesquisa a ser procurado.

• case insensitive (opcional, padrão TRUE): Se TRUE, a comparação não diferencia maiúsculas de minúsculas. Se FALSE, a comparação diferencia maiúsculas de minúsculas.

• whole word match (opcional, padrão FALSE): Se TRUE, apenas correspondências de palavras inteiras são consideradas. se term = 'here', então o valor 'are you here' corresponderá, mas o termo 'are you there' NÃO corresponderá

Exemplo:

CONTAINS([Value], "risk")         -- TRUE if 'risk' appears (case-insensitive by default)

CONTAINS([Value], "Risk", FALSE)  -- Case-sensitive; TRUE only if exact 'Risk' occurs

CONTAINS([Value], "risk", TRUE, TRUE)    -- Whole word search (e.g. 'risk' not 'risky')

CONTAINS("The quick brown fox", "quick", TRUE)  -- returns TRUE

CONTAINS("Thequickbrownfox", "quick", TRUE, TRUE) -- returns FALSE (not a whole word)

CONTAINS([Title], "", TRUE)                       -- returns FALSE (empty needle)

CONTAINS(NULL, "any")                             -- returns FALSE

Determina se uma string alvo (value) começa com um termo de pesquisa especificado (term). Retorna um booleano (TRUE / FALSE), TRUE somente se a correspondência ocorrer no início (posição 0).

Sintaxe:

STARTSWITH(value, term, {case insensitive}, {whole word match})

• value (obrigatório): O texto a ser pesquisado.

• term (obrigatório): O termo de pesquisa a ser procurado.

• case insensitive (opcional, padrão TRUE): Se TRUE, a comparação não diferencia maiúsculas de minúsculas. Se FALSE, a comparação diferencia maiúsculas de minúsculas.

• whole word match (opcional, padrão FALSE): Se TRUE, apenas correspondências de palavras inteiras são consideradas. se term = 'are', então o valor 'are you here' corresponderá, mas o termo 'aren't you here' NÃO corresponderá

Exemplo:

STARTSWITH([Value], "proj") -- TRUE if Title starts with "proj" (case-insensitive)

STARTSWITH([Value], "Proj", FALSE)   -- Case-sensitive; TRUE only if exact "Proj" case

STARTSWITH("Project Alpha", "Project", TRUE, TRUE)   -- TRUE (word boundary)

STARTSWITH("ProjectAlpha", "Project", TRUE, TRUE)    -- FALSE (no word boundary)

STARTSWITH("Header", "Head", TRUE, TRUE)             -- FALSE ('e' - not a word boundary)

STARTSWITH([Code], "")                               -- FALSE (empty needle)

STARTSWITH(NULL, "Any")                              -- FALSE

Determina se uma string alvo (value) termina com um termo de pesquisa especificado (term). Retorna um booleano (TRUE / FALSE), TRUE somente se a correspondência ocorrer no final.

Sintaxe:

ENDSWITH(value, term, {case insensitive}, {whole word match})

• value (obrigatório): O texto a ser pesquisado.

• term (obrigatório): O termo de pesquisa a ser procurado.

• case insensitive (opcional, padrão TRUE): Se TRUE, a comparação não diferencia maiúsculas de minúsculas. Se FALSE, a comparação diferencia maiúsculas de minúsculas.

• whole word match (opcional, padrão FALSE): Se TRUE, apenas correspondências de palavras inteiras são consideradas. se term = 'here', então o valor 'are you here' corresponderá, mas o termo 'are you there' NÃO corresponderá

Exemplo:

ENDSWITH([Value], "status")        -- TRUE if Title ends with "status" (case-insensitive)

ENDSWITH([Value], "Status", FALSE)   -- Case-sensitive; TRUE only if exact "Status"

ENDSWITH("Task done", "done", TRUE, TRUE)       -- TRUE (word boundary)

ENDSWITH("Taskdone", "done", TRUE, TRUE)        -- FALSE (no word boundary)

ENDSWITH("pretestpost", "test", FALSE, TRUE)    -- FALSE (no word boundary)

ENDSWITH([Note], "", TRUE)                      -- FALSE (empty needle)

ENDSWITH(NULL, "anything")                      -- FALSE

Calcula a diferença entre duas datas.

DIFF(start, end, unit)

Unidades suportadas:

• d, day, days

• m, month, months

• y, year, years

Exemplos:

DIFF([_StartDate], [_EndDate], 'day')
DIFF([_StartDate], [_EndDate], 'month')

As datas são avaliadas internamente usando milissegundos de época.

Retorna o valor absoluto.

ABS(DIFF([_StartDate], [_EndDate], 'day'))

Útil quando a ordem das datas é incerta.

IF(
  DIFF([_EndDate], [_StartDate], 'day') < 0,
  "Reversed",
  "Forward"
)

[Tier] + "-" + [_RiskLevel]

Resultado:

Gold-Medium

Limite simples:

IF([Prop.Score] >= 85, "Pass", "Review")

Categorização em níveis:

CASE(
  [Prop.Score] >= 90, "Gold",
  [Prop.Score] >= 80, "Silver",
  "Bronze"
)

([IsProgram] AND NOT [IsAutoSchedule]) OR ([Tier] = "Gold")

Regras de coerção booleana:

• "true" / "false" reconhecidos

• String não vazia → TRUE

• 0 → FALSE

• NULL → FALSE

1. Os parênteses estão balanceados.

2. IF tem exatamente três argumentos.

3. CASE tem um número ímpar de argumentos (o último é o padrão).

4. Os nomes de campos estão entre [ ].

5. As strings usam aspas ("text" ou 'text').

• Use letras maiúsculas para funções (IF, CASE, COALESCE).

• Indente expressões de várias linhas para melhor legibilidade.

• Ordene as comparações do maior para o menor limite.

• Prefira CASE para lógica complexa com múltiplas condições.