@burgan-tech/morph-touch-runtime 0.0.2

package/touch/Workflows/src/ValidateSlotForRandevuUpdateMapping.csx

@@ -0,0 +1,211 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using BBT.Workflow.Scripting;
+using BBT.Workflow.Definitions;
+
+/// <summary>
+/// Mapping for validate-slot-for-rezervation task in randevu-update flow.
+/// Same logic as ValidateSlotForRezervationMapping - uses advisor, startDateTime, endDateTime from instance.
+/// </summary>
+internal sealed class GetAvailableSlotsExceptionRandevuUpdate : Exception
+{
+    public GetAvailableSlotsExceptionRandevuUpdate(string message) : base(message) { }
+}
+
+public class ValidateSlotForRandevuUpdateMapping : ScriptBase, IMapping
+{
+    public Task<ScriptResponse> InputHandler(WorkflowTask task, ScriptContext context)
+    {
+        try
+        {
+            var serviceTask = task as DaprServiceTask;
+            if (serviceTask == null)
+                throw new InvalidOperationException("Task must be a DaprServiceTask");
+
+            var appId = GetConfigValue("DAPR_APP_ID");
+            if (!string.IsNullOrEmpty(appId))
+                serviceTask.SetAppId(appId);
+
+            var data = context.Instance?.Data;
+            if (data == null)
+                throw new InvalidOperationException("Instance data is required");
+
+            var advisor = GetString(data, "advisor");
+            var startDateTimeStr = GetString(data, "startDateTime");
+            if (string.IsNullOrEmpty(advisor) || string.IsNullOrEmpty(startDateTimeStr))
+            {
+                return Task.FromResult(new ScriptResponse
+                {
+                    Key = "validation-error",
+                    Data = new { slotCheckResult = new { available = false, key = "validation-error" } }
+                });
+            }
+
+            DateTime startDateTime;
+            if (!DateTime.TryParse(startDateTimeStr, out startDateTime))
+            {
+                return Task.FromResult(new ScriptResponse
+                {
+                    Key = "validation-error",
+                    Data = new { slotCheckResult = new { available = false, key = "validation-error" } }
+                });
+            }
+
+            var dateStr = startDateTime.ToString("yyyy-MM-dd");
+            var queryParams = new List<string>
+            {
+                "advisorId=" + Uri.EscapeDataString(advisor),
+                "date=" + Uri.EscapeDataString(dateStr)
+            };
+            serviceTask.SetQueryString(string.Join("&", queryParams));
+
+            return Task.FromResult(new ScriptResponse());
+        }
+        catch (Exception ex)
+        {
+            return Task.FromResult(new ScriptResponse
+            {
+                Key = "input-error",
+                Data = new { slotCheckResult = new { available = false, key = "input-error", error = ex.Message } }
+            });
+        }
+    }
+
+    public Task<ScriptResponse> OutputHandler(ScriptContext context)
+    {
+        var body = context.Body;
+        if (body != null && body.isSuccess == false)
+        {
+            var dataNode = body.data ?? body.Data;
+            var detail = GetString(dataNode, "detail") ?? GetString(body, "errorMessage") ?? GetString(body, "detail");
+            throw new ArgumentException(detail ?? "", "");
+        }
+        try
+        {
+            var data = context.Instance?.Data;
+            if (data == null)
+            {
+                return Task.FromResult(new ScriptResponse
+                {
+                    Data = new { slotCheckResult = new { available = false, key = "no-instance-data" } }
+                });
+            }
+
+            var startDateTimeStr = GetString(data, "startDateTime");
+            var endDateTimeStr = GetString(data, "endDateTime");
+            if (string.IsNullOrEmpty(startDateTimeStr) || string.IsNullOrEmpty(endDateTimeStr))
+            {
+                return Task.FromResult(new ScriptResponse
+                {
+                    Data = new { slotCheckResult = new { available = false, key = "validation-error" } }
+                });
+            }
+
+            DateTime startDt = DateTime.MinValue;
+            DateTime endDt = DateTime.MinValue;
+            try
+            {
+                startDt = DateTime.Parse(startDateTimeStr);
+                endDt = DateTime.Parse(endDateTimeStr);
+            }
+            catch (Exception)
+            {
+                return Task.FromResult(new ScriptResponse
+                {
+                    Data = new { slotCheckResult = new { available = false, key = "validation-error" } }
+                });
+            }
+
+            var requestedSlot = startDt.ToString("HH:mm") + "-" + endDt.ToString("HH:mm");
+            bool available = false;
+            string responseKey = null;
+
+            if (body != null)
+            {
+                responseKey = GetString(body, "key") ?? GetString(body, "Key");
+                var dataNode = body.data ?? body.Data ?? body;
+                if (dataNode != null && HasProperty(dataNode, "getAvailableSlots"))
+                {
+                    var getAvailableSlots = dataNode.getAvailableSlots;
+                    if (HasProperty(getAvailableSlots, "availableSlots"))
+                    {
+                        var availableSlots = getAvailableSlots.availableSlots;
+                        if (availableSlots != null)
+                        {
+                            var list = availableSlots as IEnumerable<object>;
+                            if (list != null)
+                            {
+                                foreach (var s in list)
+                                {
+                                    if (s?.ToString() == requestedSlot) { available = true; break; }
+                                }
+                            }
+                        }
+                    }
+                    else
+                    {
+                        var detailMsg = GetString(dataNode, "detail") ?? GetString(body, "detail");
+                        if (!string.IsNullOrEmpty(detailMsg))
+                            throw new GetAvailableSlotsExceptionRandevuUpdate(detailMsg);
+                        return Task.FromResult(new ScriptResponse
+                        {
+                            Data = new { slotCheckResult = new { available = false, key = "validation-error" } }
+                        });
+                    }
+                }
+                if (responseKey == null && body.isSuccess == false)
+                    available = false;
+            }
+
+            return Task.FromResult(new ScriptResponse
+            {
+                Data = new
+                {
+                    slotCheckResult = new
+                    {
+                        available,
+                        key = responseKey ?? (available ? "available-slots-success" : "slot-unavailable"),
+                        slots = body?.data?.getAvailableSlots?.availableSlots ?? body?.getAvailableSlots?.availableSlots
+                    }
+                }
+            });
+        }
+        catch (GetAvailableSlotsExceptionRandevuUpdate)
+        {
+            throw;
+        }
+        catch (Exception ex)
+        {
+            return Task.FromResult(new ScriptResponse
+            {
+                Data = new
+                {
+                    slotCheckResult = new
+                    {
+                        available = false,
+                        key = "output-error",
+                        error = ex.Message,
+                        unavailable = context.Body
+                    }
+                }
+            });
+        }
+    }
+
+    private string GetString(dynamic obj, string name)
+    {
+        if (obj == null) return null;
+        try
+        {
+            if (HasProperty(obj, name))
+            {
+                var v = GetPropertyValue(obj, name);
+                return v?.ToString();
+            }
+        }
+        catch { }
+        return null;
+    }
+}

package/touch/Workflows/src/ValidateSlotForRezervationMapping.csx

@@ -0,0 +1,246 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using BBT.Workflow.Scripting;
+using BBT.Workflow.Definitions;
+
+/// <summary>
+/// Mapping for validate-slot-for-rezervation task.
+/// Invokes get-available-slots function with advisor and date from rezervation instance,
+/// then checks if the requested startDateTime-endDateTime slot is in the available slots list.
+/// Output: slotCheckResult { available: bool, key?: string } for use by validating state auto transitions.
+/// </summary>
+internal sealed class GetAvailableSlotsException : Exception
+{
+    public GetAvailableSlotsException(string message) : base(message) { }
+}
+
+public class ValidateSlotForRezervationMapping : ScriptBase, IMapping
+{
+    public Task<ScriptResponse> InputHandler(WorkflowTask task, ScriptContext context)
+    {
+        try
+        {
+            var serviceTask = task as DaprServiceTask;
+            if (serviceTask == null)
+                throw new InvalidOperationException("Task must be a DaprServiceTask");
+
+            var appId = GetConfigValue("DAPR_APP_ID");
+            if (!string.IsNullOrEmpty(appId))
+                serviceTask.SetAppId(appId);
+
+            var data = context.Instance?.Data;
+            if (data == null)
+                throw new InvalidOperationException("Instance data is required");
+
+            var advisor = GetString(data, "advisor");
+            var startDateTimeStr = GetString(data, "startDateTime");
+            if (string.IsNullOrEmpty(advisor) || string.IsNullOrEmpty(startDateTimeStr))
+            {
+                return Task.FromResult(new ScriptResponse
+                {
+                    Key = "validation-error",
+                    Data = new
+                    {
+                        slotCheckResult = new { available = false, key = "validation-error" }
+                    }
+                });
+            }
+
+            DateTime startDateTime;
+            if (!DateTime.TryParse(startDateTimeStr, out startDateTime))
+            {
+                return Task.FromResult(new ScriptResponse
+                {
+                    Key = "validation-error",
+                    Data = new
+                    {
+                        slotCheckResult = new { available = false, key = "validation-error" }
+                    }
+                });
+            }
+
+            var dateStr = startDateTime.ToString("yyyy-MM-dd");
+            var queryParams = new List<string>
+            {
+                "advisorId=" + Uri.EscapeDataString(advisor),
+                "date=" + Uri.EscapeDataString(dateStr)
+            };
+            serviceTask.SetQueryString(string.Join("&", queryParams));
+
+            return Task.FromResult(new ScriptResponse());
+        }
+        catch (Exception ex)
+        {
+            return Task.FromResult(new ScriptResponse
+            {
+                Key = "input-error",
+                Data = new
+                {
+                    slotCheckResult = new
+                    {
+                        available = false,
+                        key = "input-error",
+                        error = ex.Message
+                    }
+                }
+            });
+        }
+    }
+
+    public  Task<ScriptResponse> OutputHandler(ScriptContext context)
+    {
+         var body = context.Body;
+            if (body != null && HasProperty(body, "isSuccess") && body.isSuccess == false)
+            {
+                var errNode = HasProperty(body, "data") ? body.data : null;
+                var detail = GetString(errNode, "detail") ?? GetString(body, "errorMessage") ?? GetString(body, "detail");
+                throw new ArgumentException(detail ?? "Function call failed","");
+            }
+        try
+        {
+            var data = context.Instance?.Data;
+            if (data == null)
+            {
+                return Task.FromResult(new ScriptResponse
+                {
+                    Data = new { slotCheckResult = new { available = false, key = "no-instance-data" } }
+                });
+            }
+
+            var startDateTimeStr = GetString(data, "startDateTime");
+            var endDateTimeStr = GetString(data, "endDateTime");
+            if (string.IsNullOrEmpty(startDateTimeStr) || string.IsNullOrEmpty(endDateTimeStr))
+            {
+                return Task.FromResult(new ScriptResponse
+                {
+                    Data = new { slotCheckResult = new { available = false, key = "validation-error" } }
+                });
+            }
+
+            DateTime startDt = DateTime.MinValue;
+            DateTime endDt = DateTime.MinValue;
+            try
+            {
+                startDt = DateTime.Parse(startDateTimeStr);
+                endDt = DateTime.Parse(endDateTimeStr);
+            }
+            catch (Exception ex)
+            {
+                return Task.FromResult(new ScriptResponse
+                {
+                    Data = new { slotCheckResult = new { available = false, key = "validation-error" } }
+                });
+            }
+
+            var requestedSlot = startDt.ToString("HH:mm") + "-" + endDt.ToString("HH:mm");
+
+            bool available = false;
+            string responseKey = null;
+            dynamic resolvedSlots = null;
+
+            if (body != null)
+            {
+                responseKey = GetString(body, "key") ?? GetString(body, "Key");
+
+                dynamic slotsContainer = null;
+
+                if (HasProperty(body, "getAvailableSlots"))
+                {
+                    slotsContainer = body.getAvailableSlots;
+                }
+                else
+                {
+                    var dataNode = HasProperty(body, "data") ? body.data : (HasProperty(body, "Data") ? body.Data : null);
+                    if (dataNode != null && HasProperty(dataNode, "getAvailableSlots"))
+                    {
+                        slotsContainer = dataNode.getAvailableSlots;
+                    }
+                    else if (dataNode != null && HasProperty(dataNode, "availableSlots"))
+                    {
+                        slotsContainer = dataNode;
+                    }
+                }
+
+                if (slotsContainer != null && HasProperty(slotsContainer, "availableSlots"))
+                {
+                    var availableSlots = slotsContainer.availableSlots;
+                    resolvedSlots = availableSlots;
+                    if (availableSlots != null)
+                    {
+                        var list = availableSlots as IEnumerable<object>;
+                        if (list != null)
+                        {
+                            foreach (var s in list)
+                            {
+                                var slotStr = s?.ToString();
+                                if (slotStr == requestedSlot)
+                                {
+                                    available = true;
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                }
+                else
+                {
+                    var detailMsg = GetString(body, "detail");
+                    if (!string.IsNullOrEmpty(detailMsg))
+                        throw new GetAvailableSlotsException(detailMsg);
+                }
+
+                if (responseKey == null && HasProperty(body, "isSuccess") && body.isSuccess == false)
+                    available = false;
+            }
+            return Task.FromResult(new ScriptResponse
+            {
+                Data = new
+                {
+                    slotCheckResult = new
+                    {
+                        available,
+                        key = responseKey ?? (available ? "available-slots-success" : "slot-unavailable"),
+                        slots = resolvedSlots
+                    }
+                }
+            });
+
+        }
+        catch (GetAvailableSlotsException)
+        {
+            throw;
+        }
+        catch (Exception ex)
+        {
+            return Task.FromResult(new ScriptResponse
+            {
+                Data = new
+                {
+                    slotCheckResult = new
+                    {
+                        available = false,
+                        key = "output-error",
+                        error = ex.Message
+                    }
+                }
+            });
+        }
+    }
+
+    private string GetString(dynamic obj, string name)
+    {
+        if (obj == null) return null;
+        try
+        {
+            if (HasProperty(obj, name))
+            {
+                var v = GetPropertyValue(obj, name);
+                return v?.ToString();
+            }
+        }
+        catch { }
+        return null;
+    }
+}

package/touch/Workflows/src/ValidateTransferMapping.csx

@@ -0,0 +1,243 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using BBT.Workflow.Scripting;
+using BBT.Workflow.Definitions;
+
+/// <summary>
+/// Mapping for validate-transfer-availability task (DaprServiceTask - Type 3).
+/// Queries all active reservations in the date range for target advisors.
+/// OutputHandler checks each transferPlan item to see if the target advisor
+/// still has a free slot at the reservation's timeslot.
+/// Sets validationResult.allValid = true/false accordingly.
+/// </summary>
+public class ValidateTransferMapping : ScriptBase, IMapping
+{
+    public Task<ScriptResponse> InputHandler(WorkflowTask task, ScriptContext context)
+    {
+        var serviceTask = task as DaprServiceTask;
+        if (serviceTask == null)
+            throw new InvalidOperationException("Task must be a DaprServiceTask");
+
+        var appId = GetConfigValue("DAPR_APP_ID");
+        if (!string.IsNullOrEmpty(appId))
+            serviceTask.SetAppId(appId);
+
+        var data = context.Instance?.Data;
+        if (data == null)
+            throw new InvalidOperationException("Instance data is required");
+
+        var transferPlan = data.transferPlan;
+        if (transferPlan == null)
+            throw new ArgumentException("transferPlan is required.", "transferPlan");
+
+        var startDate = GetString(data, "startDate");
+        var endDate = GetString(data, "endDate");
+
+        if (string.IsNullOrEmpty(startDate))
+            throw new ArgumentException("startDate is required.", "startDate");
+        if (string.IsNullOrEmpty(endDate))
+            endDate = "2099-12-31";
+
+        var conditions = new List<string>
+        {
+            "{\"or\":[" +
+                "{\"currentState\":{\"eq\":\"active\"}}," +
+                "{\"currentState\":{\"eq\":\"in-meet\"}}" +
+            "]}",
+            "{\"status\":{\"eq\":\"A\"}}",
+            "{\"attributes\":{\"startDateTime\":{\"gte\":\"" + startDate + "\"}}}",
+            "{\"attributes\":{\"endDateTime\":{\"lte\":\"" + endDate + "\"}}}"
+        };
+
+        var filterJson = "{\"and\":[" + string.Join(",", conditions) + "]}";
+        var queryParams = new List<string>
+        {
+            "pageSize=100",
+            "filter=" + filterJson
+        };
+
+        serviceTask.SetQueryString(string.Join("&", queryParams));
+        return Task.FromResult(new ScriptResponse());
+    }
+
+    public Task<ScriptResponse> OutputHandler(ScriptContext context)
+    {
+        try
+        {
+            var body = context.Body;
+            var data = context.Instance?.Data;
+
+            if (body != null && body.isSuccess == false)
+            {
+                var errorMessage = body.errorMessage?.ToString() ?? "Validation service error";
+                throw new Exception(errorMessage);
+            }
+
+            var responseData = body?.data;
+            var allItems = responseData?.items;
+
+            var transferPlan = data?.transferPlan;
+            var enrichedRezervations = data?.enrichedRezervations;
+
+            bool allValid = true;
+            var details = new List<object>();
+
+            if (transferPlan != null)
+            {
+                foreach (var planItem in transferPlan)
+                {
+                    if (planItem == null) continue;
+
+                    dynamic pi = planItem;
+                    var rezervationKey = pi.rezervationKey?.ToString();
+                    var targetAdvisor = pi.targetAdvisor?.ToString();
+
+                    if (string.IsNullOrEmpty(rezervationKey) || string.IsNullOrEmpty(targetAdvisor))
+                    {
+                        details.Add(new { rezervationKey, targetAdvisor, valid = false, reason = "missing-data" });
+                        allValid = false;
+                        continue;
+                    }
+
+                    string rezStartStr = null, rezEndStr = null;
+                    if (enrichedRezervations != null)
+                    {
+                        foreach (var er in enrichedRezervations)
+                        {
+                            if (er == null) continue;
+                            var erKey = HasProperty(er, "key") ? er.key?.ToString() : "";
+                            if (erKey == rezervationKey)
+                            {
+                                rezStartStr = HasProperty(er, "startDateTime") ? er.startDateTime?.ToString() : null;
+                                rezEndStr = HasProperty(er, "endDateTime") ? er.endDateTime?.ToString() : null;
+                                break;
+                            }
+                        }
+                    }
+
+                    if (string.IsNullOrEmpty(rezStartStr) || string.IsNullOrEmpty(rezEndStr))
+                    {
+                        details.Add(new { rezervationKey, targetAdvisor, valid = true, reason = "no-time-data-to-validate" });
+                        continue;
+                    }
+
+                    DateTime rezStart = DateTime.MinValue;
+                    DateTime rezEnd = DateTime.MinValue;
+                    if (!DateTime.TryParse(rezStartStr, out rezStart) || !DateTime.TryParse(rezEndStr, out rezEnd))
+                    {
+                        details.Add(new { rezervationKey, targetAdvisor, valid = true, reason = "unparseable-time" });
+                        continue;
+                    }
+
+                    bool hasConflict = false;
+                    if (allItems != null)
+                    {
+                        foreach (var item in allItems)
+                        {
+                            if (item == null) continue;
+                            var itemAdvisor = GetNestedString(item, "attributes", "advisor")
+                                ?? GetString(item, "advisor");
+                            if (itemAdvisor != targetAdvisor) continue;
+
+                            var itemStartStr = GetNestedString(item, "attributes", "startDateTime")
+                                ?? GetString(item, "startDateTime");
+                            var itemEndStr = GetNestedString(item, "attributes", "endDateTime")
+                                ?? GetString(item, "endDateTime");
+
+                            if (string.IsNullOrEmpty(itemStartStr) || string.IsNullOrEmpty(itemEndStr))
+                                continue;
+
+                            DateTime itemStart = DateTime.MinValue;
+                            DateTime itemEnd = DateTime.MinValue;
+                            if (DateTime.TryParse(itemStartStr, out itemStart) && DateTime.TryParse(itemEndStr, out itemEnd))
+                            {
+                                var itemKey = HasProperty(item, "key") ? item.key?.ToString() : "";
+                                if (itemKey == rezervationKey) continue;
+
+                                if (itemStart < rezEnd && itemEnd > rezStart)
+                                {
+                                    hasConflict = true;
+                                    break;
+                                }
+                            }
+                        }
+                    }
+
+                    if (hasConflict)
+                    {
+                        allValid = false;
+                        details.Add(new { rezervationKey, targetAdvisor, valid = false, reason = "slot-conflict" });
+                    }
+                    else
+                    {
+                        details.Add(new { rezervationKey, targetAdvisor, valid = true });
+                    }
+                }
+            }
+
+            return Task.FromResult(new ScriptResponse
+            {
+                Data = new
+                {
+                    validationResult = new
+                    {
+                        allValid,
+                        details
+                    },
+                    processedIndex = 0
+                }
+            });
+        }
+        catch (Exception ex)
+        {
+            return Task.FromResult(new ScriptResponse
+            {
+                Data = new
+                {
+                    validationResult = new
+                    {
+                        allValid = false,
+                        error = ex.Message
+                    }
+                }
+            });
+        }
+    }
+
+    private string GetString(dynamic obj, string name)
+    {
+        if (obj == null) return null;
+        try
+        {
+            if (HasProperty(obj, name))
+            {
+                var v = GetPropertyValue(obj, name);
+                return v?.ToString();
+            }
+        }
+        catch { }
+        return null;
+    }
+
+    private string GetNestedString(dynamic obj, string parent, string child)
+    {
+        if (obj == null) return null;
+        try
+        {
+            if (HasProperty(obj, parent))
+            {
+                var nested = GetPropertyValue(obj, parent);
+                if (nested != null && HasProperty(nested, child))
+                {
+                    var v = GetPropertyValue(nested, child);
+                    return v?.ToString();
+                }
+            }
+        }
+        catch { }
+        return null;
+    }
+}
+