Dataverse Client-Side Logic: Business Rules vs JavaScript vs Plugins for Form Validation and Automation

Scenario 1: Prevent status regression (SECURITY CRITICAL)
public void Execute(IServiceProvider serviceProvider)
{
    var context = (IPluginExecutionContext)serviceProvider.GetService(
        typeof(IPluginExecutionContext));
    
    if (context.MessageName == "Update")
    {
        var target = (Entity)context.InputParameters["Target"];
        
        // Get current status from database
        var preImage = (Entity)context.PreEntityImages["PreImage"];
        var currentStatus = preImage.GetAttributeValue<OptionSetValue>("statuscode").Value;
        
        if (target.Contains("statuscode"))
        {
            var newStatus = target.GetAttributeValue<OptionSetValue>("statuscode").Value;
            
            // Define allowed progressions
            var allowedProgressions = new Dictionary<int, List<int>>
            {
                { 1, new List<int> { 2, 3 } },      // Draft can go to Review or Cancelled
                { 2, new List<int> { 4, 3 } },      // Review can go to Approved or Cancelled
                { 4, new List<int> { } },           // Approved cannot change (locked)
                { 3, new List<int> { 1 } }          // Cancelled can return to Draft
            };
            
            // Check if progression is allowed
            if (!allowedProgressions[currentStatus].Contains(newStatus))
            {
                throw new InvalidPluginExecutionException(
                    string.Format("Cannot change status from {0} to {1}. This transition is not allowed.",
                        GetStatusName(currentStatus), GetStatusName(newStatus)));
            }
        }
    }
}

Scenario 2: Recalculate order totals when line items change
public void Execute(IServiceProvider serviceProvider)
{
    // When order line is created, updated, or deleted
    if (context.PrimaryEntityName == "salesorderdetail")
    {
        var orderId = GetOrderId(context);
        
        // Calculate totals from all line items
        var query = new QueryExpression("salesorderdetail");
        query.Criteria.AddCondition("salesorderid", ConditionOperator.Equal, orderId);
        query.ColumnSet.AddColumns("quantity", "priceperunit", "tax", "discount");
        
        var lineItems = service.RetrieveMultiple(query).Entities;
        
        decimal subtotal = 0;
        decimal totalTax = 0;
        decimal totalDiscount = 0;
        
        foreach (var line in lineItems)
        {
            var qty = line.GetAttributeValue<decimal>("quantity");
            var price = line.GetAttributeValue<Money>("priceperunit").Value;
            var tax = line.GetAttributeValue<Money>("tax").Value;
            var discount = line.GetAttributeValue<Money>("discount").Value;
            
            subtotal += qty * price;
            totalTax += tax;
            totalDiscount += discount;
        }
        
        // Update order header with calculated totals
        var order = new Entity("salesorder");
        order.Id = orderId;
        order["subtotal"] = new Money(subtotal);
        order["totaltax"] = new Money(totalTax);
        order["totaldiscount"] = new Money(totalDiscount);
        order["totalamount"] = new Money(subtotal + totalTax - totalDiscount);
        
        service.Update(order);
    }
}

Scenario 3: Prevent deletion of records with dependencies
public void Execute(IServiceProvider serviceProvider)
{
    if (context.MessageName == "Delete" && 
        context.PrimaryEntityName == "account")
    {
        var accountId = (Guid)context.PrimaryEntityId;
        
        // Check for active orders
        var orderQuery = new QueryExpression("salesorder");
        orderQuery.Criteria.AddCondition("customerid", ConditionOperator.Equal, accountId);
        orderQuery.Criteria.AddCondition("statecode", ConditionOperator.Equal, 0); // Active
        
        var activeOrders = service.RetrieveMultiple(orderQuery);
        
        if (activeOrders.Entities.Count > 0)
        {
            throw new InvalidPluginExecutionException(
                string.Format("Cannot delete account with {0} active orders. " +
                    "Please close or cancel all orders before deleting the account.",
                    activeOrders.Entities.Count));
        }
    }
}

Scenario 4: Enforce approval hierarchy based on amount
public void Execute(IServiceProvider serviceProvider)
{
    if (context.MessageName == "Update" && 
        context.PrimaryEntityName == "quote")
    {
        var target = (Entity)context.InputParameters["Target"];
        
        if (target.Contains("approverid") && target.Contains("totalamount"))
        {
            var approverId = target.GetAttributeValue<EntityReference>("approverid").Id;
            var totalAmount = target.GetAttributeValue<Money>("totalamount").Value;
            
            // Get approver's authority limit
            var approver = service.Retrieve("systemuser", approverId, 
                new ColumnSet("approvallimit"));
            var approvalLimit = approver.GetAttributeValue<Money>("approvallimit").Value;
            
            if (totalAmount > approvalLimit)
            {
                throw new InvalidPluginExecutionException(
                    string.Format("This approver can only approve quotes up to ${0:N2}. " +
                        "This quote requires approval from a manager with higher authority.",
                        approvalLimit));
            }
        }
    }
}