Integer and Float Variables in Power Automate: Explanation with Examples

 🚀 Integer and Float Variables in Power Automate: Explanation with Examples

In Power Automate, integer and float variables are used to store numerical values. Here's a breakdown of their usage, along with practical flow examples:

1️⃣ Integer Variables

• Purpose: Store whole numbers (e.g., 0, 15, -3).
• Common Actions: Initialize, increment, decrement.
• Example Flow: Counting Email Attachments
  • Scenario: Count the number of attachments in an email.
  • 🔔 Trigger: "When a new email arrives" (Office 365 Outlook).
  • 🧰 Initialize Integer Variable:
    • Name: attachmentCount
    • Type: Integer
    • Value: 0
  • 🔄 Loop Through Attachments:
    • Apply to Each (attachments):
      • 🔢 Increment Variable:
        • Name: attachmentCount
        • Value: 1
  • 📧 Send Result:

    • Send Email:

      Body: "Total attachments: @{variables('attachmentCount')}"
      

2️⃣ Float Variables

• Purpose: Store decimal numbers (e.g., 3.14, -5.67).
• Common Actions: Initialize, update via expressions.
• Example Flow: Calculating Total Order Cost

  • Scenario: Sum the prices of items in a SharePoint list.

  • 🔔 Trigger: "When an item is created" (SharePoint list with items containing a Price column).

  • 🧰 Initialize Float Variable:

    • Name: totalCost
    • Type: Float
    • Value: 0.0

  • 🔄 Loop Through Items:

    • Apply to Each (items):
      • 💰 Set Variable:

        • Name: totalCost

        • Value:

          @add(variables('totalCost'), float(item()?['Price']))
          

  • 📊 Format and Log Result:

    • Update SharePoint:

      Total: @{formatNumber(variables('totalCost'), 'C2')}
      

⚖️ Key Differences & Best Practices

• Aspect | Integer Variables | Float Variables
  • 🧰 Initialization | Initialize variable → Type: Integer | Initialize variable → Type: Float
  • 🛠️ Modification | Increment variable action | Set variable with add(), sub(), etc.
  • 📂 Use Cases | Counting, indexing, loops | Financial calculations, measurements
  • 🧰 Common Functions | add(), sub(), mul(), div() | round(), formatNumber(), float()

➕ Advanced Example: Dynamic Discount Calculation

• Scenario: Apply tiered discounts to an order total.

• 🔔 Trigger: "When a new item is added" (SharePoint list with OrderTotal).

• 🧰 Initialize Variables:

  • OrderTotal (float): @\{triggerBody()?['OrderTotal']}
  • DiscountRate (float): 0.0

• 🤔 Conditional Discounts:

  • If OrderTotal >= 1000:

    @setVariable('DiscountRate', 0.15)
    

  • Else If OrderTotal >= 500:

    @setVariable('DiscountRate', 0.10)
    

• 💰 Calculate Final Price:

  • Set Variable:

    @mul(variables('OrderTotal'), sub(1, variables('DiscountRate')))
    

• 📧 Send Approval:

  • Teams Message:

    "Final Price: @{formatNumber(variables('FinalPrice'), 'C2')}"
    

⚠️ Common Pitfalls & Solutions

• Type Mismatch: Use int() or float() to convert strings/numbers.

  @float(triggerBody()?['PriceString'])
  

• Precision Issues: Use round() to limit decimal places.

  @round(variables('totalCost'), 2)
  

• Incrementing Floats: Manually update using add().

  @add(variables('totalCost'), 2.5)
  

✅ Conclusion

• 🔢 Integers are ideal for counting and discrete values.
• ⚖️ Floats handle precise calculations involving decimals.
• Use Initialize variable, Set variable, and arithmetic functions (add(), mul()) to manage numerical logic effectively.

🏆 By leveraging these variables, you can build dynamic flows for inventory tracking, financial reporting, and more! 🚀

Variable Cascading in power automate with example

 🚀 Variable Cascading in Power Automate with Example

• Variable cascading in Power Automate refers to the sequential use of variables where each subsequent variable's value depends on the previous one.
• This approach allows you to break down complex workflows into manageable steps, enhancing readability and maintainability.
• Below is a practical example demonstrating this concept:

💰 Example: Order Processing Workflow

• Scenario: Automate order processing by validating customer eligibility, calculating discounts, and generating a final invoice. Each step uses variables that depend on prior results.

🪜 Step 1: Trigger and Initialize Variables

* 🔔   **Trigger:** "When a new item is added" to a SharePoint list (e.g., *Orders* list).
* 🧰   **Initialize Variables:**
    * 🆔   CustomerID: Store the customer ID from the trigger.

        ```
        Name: CustomerID
        Type: String
        Value: @{triggerBody()?['CustomerID']}
        ```

    * 💵   OrderTotal: Capture the raw order total.

        ```
        Name: OrderTotal
        Type: Float
        Value: @{triggerBody()?['Amount']}
        ```

🪜 Step 2: Fetch Customer Details

* 🧑‍🤝‍🧑   Get Customer Tier:
    * Use "Get item" (SharePoint) to fetch the customer’s membership tier using *CustomerID*.
* 🗄️   Store the result in a variable:

    ```
    Name: CustomerTier
    Type: String
    Value: @{outputs('Get_Customer_Details')?['body/Tier']}
    ```

🪜 Step 3: Calculate Discount Based on Tier

* 💸   Set Discount Rate:
    * Use a Condition to determine the discount:

        ```
        If CustomerTier = "Gold", set DiscountRate = 0.15
        Else if CustomerTier = "Silver", set DiscountRate = 0.10
        Else, set DiscountRate = 0.05
        ```

* 💰   Initialize Variable:

    ```
    Name: DiscountRate
    Type: Float
    Value: @{body('Condition')}
    ```

🪜 Step 4: Compute Final Amount

* 🧾   Calculate Final Total:
    * Set Variable:

        ```
        Name: FinalAmount
        Type: Float
        Value: @{mul(variables('OrderTotal'), sub(1, variables('DiscountRate'))}
        ```

🪜 Step 5: Generate Invoice

* 📄   Create Invoice:
    * Use "Create file" (OneDrive) to save the invoice with dynamic content:

        ```
        File Name: Invoice_@{variables('CustomerID')}.txt
        Content:
          "Customer: @{variables('CustomerID')}
          Order Total: $@{variables('OrderTotal')}
          Discount: @{mul(variables('DiscountRate'), 100)}%
          Final Amount: $@{variables('FinalAmount')}"
        ```

🔑 Key Points

* **Cascading Dependencies:**
    * CustomerID → Used to fetch CustomerTier.
    * CustomerTier → Determines DiscountRate.
    * DiscountRate + OrderTotal → Compute FinalAmount.
* **Benefits:**
    * 🧩   Modularity: Each step is isolated and reusable.
    * ✅   Clarity: Variables make the flow self-documenting.
    * 🔧   Flexibility: Easily update discount rates or logic without disrupting the entire flow.

🔄 Advanced Use Case: Multi-Level Approvals

* **Scenario:** Escalate approval requests based on dynamic thresholds.
* **Initialize Variables:** ApprovalLevel = 1, MaxApprovalLevel = 3.
* **Loop:** While ApprovalLevel <= MaxApprovalLevel:
    * Send approval to the corresponding team.
    * If rejected, increment ApprovalLevel.
    * If approved, exit loop.

✨ Best Practices

* 🏷️   Descriptive Names: Use clear variable names (e.g., DiscountRate, not var1).
* 🧱   Scope Management: Use Scope actions to group related variables.
* 🚨   Error Handling: Add checks for null/empty variables.

🏆 By cascading variables, you create 🚀 dynamic, adaptable workflows that mirror real-world business logic. This method is particularly useful for financial calculations, approval chains, and data transformations. 🚀