@burgan-tech/morph-touch-runtime 0.0.2

package/touch/Workflows/src/EnrichRezervationsForTransferMapping.csx

@@ -0,0 +1,495 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using BBT.Workflow.Scripting;
+using BBT.Workflow.Definitions;
+
+/// <summary>
+/// Mapping for enrich-rezervations-for-transfer task (DaprServiceTask - Type 3).
+/// Queries ALL active reservations in the date range across all advisors.
+/// OutputHandler enriches each source advisor's reservation with a list of advisors
+/// that are available based on: reservation conflicts, working hours, public holidays,
+/// and personal leaves (using absenceEntries from previous task).
+/// </summary>
+public class EnrichRezervationsForTransferMapping : 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 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() ?? "Failed to fetch all reservations";
+                throw new Exception(errorMessage);
+            }
+
+            var sourceAdvisorId = GetString(data, "sourceAdvisorId");
+            var sourceRezervations = data?.rezervations;
+
+            var responseData = body?.data;
+            var allItems = responseData?.items;
+
+            var publicHolidays = new List<dynamic>();
+            var advisorWorkHoursMap = new Dictionary<string, List<dynamic>>();
+            var companyWorkHours = new List<dynamic>();
+            var personalLeavesMap = new Dictionary<string, List<dynamic>>();
+
+            var absenceEntries = data?.absenceEntries;
+            if (absenceEntries != null)
+            {
+                foreach (var entry in absenceEntries)
+                {
+                    if (entry == null) continue;
+                    var attrs = entry?.attributes;
+                    if (attrs == null) continue;
+
+                    var absenceType = GetString(attrs, "absenceType");
+                    var advisor = GetString(attrs, "advisor");
+
+                    switch (absenceType)
+                    {
+                        case "public-holiday":
+                            publicHolidays.Add(entry);
+                            break;
+                        case "working-hours-change":
+                            if (!string.IsNullOrEmpty(advisor))
+                            {
+                                if (!advisorWorkHoursMap.ContainsKey(advisor))
+                                    advisorWorkHoursMap[advisor] = new List<dynamic>();
+                                advisorWorkHoursMap[advisor].Add(entry);
+                            }
+                            else
+                            {
+                                companyWorkHours.Add(entry);
+                            }
+                            break;
+                        case "personal-leave":
+                            if (!string.IsNullOrEmpty(advisor))
+                            {
+                                if (!personalLeavesMap.ContainsKey(advisor))
+                                    personalLeavesMap[advisor] = new List<dynamic>();
+                                personalLeavesMap[advisor].Add(entry);
+                            }
+                            break;
+                    }
+                }
+            }
+
+            var enriched = new List<object>();
+
+            if (sourceRezervations != null)
+            {
+                foreach (var rez in sourceRezervations)
+                {
+                    if (rez == null) continue;
+
+                    var rezStartStr = GetNestedString(rez, "attributes", "startDateTime")
+                        ?? GetString(rez, "startDateTime");
+                    var rezEndStr = GetNestedString(rez, "attributes", "endDateTime")
+                        ?? GetString(rez, "endDateTime");
+                    var rezKey = HasProperty(rez, "key") ? rez.key?.ToString() : "";
+                    var rezUser = GetNestedString(rez, "attributes", "user")
+                        ?? GetString(rez, "user");
+                    var rezAdvisor = GetNestedString(rez, "attributes", "advisor")
+                        ?? GetString(rez, "advisor");
+
+                    var busyAdvisors = new HashSet<string>();
+                    if (!string.IsNullOrEmpty(sourceAdvisorId))
+                        busyAdvisors.Add(sourceAdvisorId);
+
+                    DateTime rezStart = DateTime.MinValue;
+                    DateTime rezEnd = DateTime.MinValue;
+                    if (!string.IsNullOrEmpty(rezStartStr) && !string.IsNullOrEmpty(rezEndStr) &&
+                        DateTime.TryParse(rezStartStr, out rezStart) && DateTime.TryParse(rezEndStr, out rezEnd) &&
+                        allItems != null)
+                    {
+                        foreach (var item in allItems)
+                        {
+                            if (item == null) continue;
+                            var itemAdvisor = GetNestedString(item, "attributes", "advisor")
+                                ?? GetString(item, "advisor");
+                            var itemStartStr = GetNestedString(item, "attributes", "startDateTime")
+                                ?? GetString(item, "startDateTime");
+                            var itemEndStr = GetNestedString(item, "attributes", "endDateTime")
+                                ?? GetString(item, "endDateTime");
+
+                            if (string.IsNullOrEmpty(itemAdvisor) || 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))
+                            {
+                                if (itemStart < rezEnd && itemEnd > rezStart)
+                                {
+                                    busyAdvisors.Add(itemAdvisor);
+                                }
+                            }
+                        }
+                    }
+
+                    var allAdvisors = new HashSet<string>();
+                    var advisorKeys = data?.allAdvisorKeys;
+                    if (advisorKeys != null)
+                    {
+                        foreach (var ak in advisorKeys)
+                        {
+                            if (ak == null) continue;
+                            var key = ak?.ToString();
+                            if (!string.IsNullOrEmpty(key))
+                                allAdvisors.Add(key);
+                        }
+                    }
+
+                    var available = new List<string>();
+                    foreach (var adv in allAdvisors)
+                    {
+                        if (busyAdvisors.Contains(adv))
+                            continue;
+
+                        if (rezStart != DateTime.MinValue && rezEnd != DateTime.MinValue)
+                        {
+                            if (!IsSlotAvailableForAdvisor(adv, rezStart, rezEnd,
+                                publicHolidays, advisorWorkHoursMap, companyWorkHours, personalLeavesMap))
+                                continue;
+                        }
+
+                        available.Add(adv);
+                    }
+
+                    enriched.Add(new
+                    {
+                        key = rezKey,
+                        startDateTime = rezStartStr,
+                        endDateTime = rezEndStr,
+                        user = rezUser,
+                        advisor = rezAdvisor,
+                        availableAdvisors = available
+                    });
+                }
+            }
+
+            var result = new Dictionary<string, object>();
+            result["sourceAdvisorId"] = sourceAdvisorId;
+            result["advisorType"] = GetString(data, "advisorType");
+            result["startDate"] = GetString(data, "startDate");
+            result["endDate"] = GetString(data, "endDate");
+            result["transferType"] = GetString(data, "transferType");
+            result["enrichedRezervations"] = enriched;
+            result["rezervations"] = new List<object>();
+            result["absenceEntries"] = new List<object>();
+            result["allAdvisorKeys"] = new List<string>();
+
+            return Task.FromResult(new ScriptResponse
+            {
+                Data = result
+            });
+        }
+        catch (Exception ex)
+        {
+            return Task.FromResult(new ScriptResponse
+            {
+                Data = new
+                {
+                    error = "Failed to enrich reservations",
+                    errorDescription = ex.Message
+                }
+            });
+        }
+    }
+
+    #region Slot Availability
+
+    private bool IsSlotAvailableForAdvisor(string advisorKey, DateTime rezStart, DateTime rezEnd,
+        List<dynamic> publicHolidays,
+        Dictionary<string, List<dynamic>> advisorWorkHoursMap,
+        List<dynamic> companyWorkHours,
+        Dictionary<string, List<dynamic>> personalLeavesMap)
+    {
+        var rezDate = rezStart.Date;
+        var dayOfWeek = rezDate.DayOfWeek.ToString().ToLower();
+        var slotStart = rezStart.TimeOfDay;
+        var slotEnd = rezEnd.TimeOfDay;
+
+        var holidayRanges = GetHolidayRanges(publicHolidays, rezDate);
+        if (holidayRanges != null && holidayRanges.Count == 1
+            && holidayRanges[0].Item1 == TimeSpan.Zero
+            && holidayRanges[0].Item2 >= new TimeSpan(23, 59, 0))
+            return false;
+
+        List<dynamic> advWorkHours = null;
+        if (advisorWorkHoursMap.ContainsKey(advisorKey))
+            advWorkHours = advisorWorkHoursMap[advisorKey];
+
+        var workHours = GetWorkingHoursForDay(advWorkHours, dayOfWeek);
+        if (workHours == null || workHours.Count == 0)
+            workHours = GetWorkingHoursForDay(companyWorkHours, dayOfWeek);
+
+        if (workHours == null || workHours.Count == 0)
+            return false;
+
+        bool slotInWorkHours = false;
+        foreach (var wh in workHours)
+        {
+            dynamic whDyn = wh;
+            var startStr = whDyn?.start?.ToString();
+            var endStr = whDyn?.end?.ToString();
+            if (string.IsNullOrEmpty(startStr) || string.IsNullOrEmpty(endStr))
+                continue;
+
+            TimeSpan whStart = TimeSpan.MinValue;
+            TimeSpan whEnd = TimeSpan.MinValue;
+            if (!TimeSpan.TryParse(startStr, out whStart) || !TimeSpan.TryParse(endStr, out whEnd))
+                continue;
+
+            if (slotStart >= whStart && slotEnd <= whEnd)
+            {
+                slotInWorkHours = true;
+                break;
+            }
+        }
+
+        if (!slotInWorkHours)
+            return false;
+
+        var unavailableRanges = new List<Tuple<TimeSpan, TimeSpan>>();
+
+        List<dynamic> advLeaves = null;
+        if (personalLeavesMap.ContainsKey(advisorKey))
+            advLeaves = personalLeavesMap[advisorKey];
+        if (advLeaves != null)
+            unavailableRanges.AddRange(GetUnavailableRanges(advLeaves, rezDate));
+
+        if (holidayRanges != null)
+            unavailableRanges.AddRange(holidayRanges);
+
+        foreach (var ur in unavailableRanges)
+        {
+            if (slotStart < ur.Item2 && slotEnd > ur.Item1)
+                return false;
+        }
+
+        return true;
+    }
+
+    private List<Tuple<TimeSpan, TimeSpan>> GetHolidayRanges(List<dynamic> holidays, DateTime date)
+    {
+        var ranges = new List<Tuple<TimeSpan, TimeSpan>>();
+        bool hasHoliday = false;
+
+        foreach (var holiday in holidays)
+        {
+            var holidayData = holiday?.attributes;
+            if (holidayData == null) continue;
+
+            string startDateTimeStr = GetString(holidayData, "startDateTime");
+            string endDateTimeStr = GetString(holidayData, "endDateTime");
+
+            if (string.IsNullOrEmpty(startDateTimeStr) || string.IsNullOrEmpty(endDateTimeStr))
+                continue;
+
+            DateTime startDateTime = DateTime.MinValue;
+            DateTime endDateTime = DateTime.MinValue;
+            if (!DateTime.TryParse(startDateTimeStr, out startDateTime) || !DateTime.TryParse(endDateTimeStr, out endDateTime))
+                continue;
+
+            if (date.Date < startDateTime.Date || date.Date > endDateTime.Date)
+                continue;
+
+            hasHoliday = true;
+
+            if (startDateTime.Date != endDateTime.Date)
+            {
+                if (date.Date == startDateTime.Date)
+                    ranges.Add(Tuple.Create(startDateTime.TimeOfDay, new TimeSpan(23, 59, 59)));
+                else if (date.Date == endDateTime.Date)
+                    ranges.Add(Tuple.Create(TimeSpan.Zero, endDateTime.TimeOfDay));
+                else
+                    ranges.Add(Tuple.Create(TimeSpan.Zero, new TimeSpan(23, 59, 59)));
+            }
+            else
+            {
+                ranges.Add(Tuple.Create(startDateTime.TimeOfDay, endDateTime.TimeOfDay));
+            }
+        }
+
+        return hasHoliday ? ranges : null;
+    }
+
+    private List<object> GetWorkingHoursForDay(List<dynamic> workingHoursChanges, string dayOfWeek)
+    {
+        if (workingHoursChanges == null) return null;
+
+        foreach (var change in workingHoursChanges)
+        {
+            var changeData = change?.attributes;
+            if (changeData == null) continue;
+
+            var customWH = changeData?.customWorkingHours;
+            if (customWH == null) continue;
+
+            var dayHours = GetDayHoursFromCustom(customWH, dayOfWeek);
+            if (dayHours != null) return dayHours;
+        }
+
+        return null;
+    }
+
+    private List<object> GetDayHoursFromCustom(dynamic customWH, string dayOfWeek)
+    {
+        dynamic dayHours = null;
+        switch (dayOfWeek)
+        {
+            case "monday": dayHours = customWH?.monday; break;
+            case "tuesday": dayHours = customWH?.tuesday; break;
+            case "wednesday": dayHours = customWH?.wednesday; break;
+            case "thursday": dayHours = customWH?.thursday; break;
+            case "friday": dayHours = customWH?.friday; break;
+            case "saturday": dayHours = customWH?.saturday; break;
+            case "sunday": dayHours = customWH?.sunday; break;
+        }
+
+        if (dayHours == null) return null;
+
+        var result = new List<object>();
+        foreach (var range in dayHours)
+        {
+            var start = range?.start?.ToString();
+            var end = range?.end?.ToString();
+            if (!string.IsNullOrEmpty(start) && !string.IsNullOrEmpty(end))
+            {
+                result.Add(new { start, end });
+            }
+        }
+        return result.Count > 0 ? result : null;
+    }
+
+    private List<Tuple<TimeSpan, TimeSpan>> GetUnavailableRanges(List<dynamic> personalLeaves, DateTime date)
+    {
+        var ranges = new List<Tuple<TimeSpan, TimeSpan>>();
+
+        foreach (var leave in personalLeaves)
+        {
+            var leaveData = leave?.attributes;
+            if (leaveData == null) continue;
+
+            string startDateTimeStr = GetString(leaveData, "startDateTime");
+            string endDateTimeStr = GetString(leaveData, "endDateTime");
+
+            if (string.IsNullOrEmpty(startDateTimeStr) || string.IsNullOrEmpty(endDateTimeStr))
+                continue;
+
+            DateTime startDateTime = DateTime.MinValue;
+            DateTime endDateTime = DateTime.MinValue;
+            if (!DateTime.TryParse(startDateTimeStr, out startDateTime) || !DateTime.TryParse(endDateTimeStr, out endDateTime))
+                continue;
+
+            if (date.Date < startDateTime.Date || date.Date > endDateTime.Date)
+                continue;
+
+            if (startDateTime.Date != endDateTime.Date)
+            {
+                if (date.Date == startDateTime.Date)
+                    ranges.Add(Tuple.Create(startDateTime.TimeOfDay, new TimeSpan(23, 59, 59)));
+                else if (date.Date == endDateTime.Date)
+                    ranges.Add(Tuple.Create(TimeSpan.Zero, endDateTime.TimeOfDay));
+                else
+                    ranges.Add(Tuple.Create(TimeSpan.Zero, new TimeSpan(23, 59, 59)));
+            }
+            else
+            {
+                ranges.Add(Tuple.Create(startDateTime.TimeOfDay, endDateTime.TimeOfDay));
+            }
+        }
+
+        return ranges;
+    }
+
+    #endregion
+
+    #region Helpers
+
+    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;
+    }
+
+    #endregion
+}

package/touch/Workflows/src/ExecutePermanentChatRoomUpdateMapping.csx

@@ -0,0 +1,124 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using BBT.Workflow.Scripting;
+using BBT.Workflow.Definitions;
+
+/// <summary>
+/// Mapping for execute-permanent-chatroom-update DirectTriggerTask (Type 12).
+/// Processes one permanent chat room at a time from permanentRoomPlan.
+/// Termination (transferType == "termination") → triggers 'transfer' transition (old advisor out, new in).
+/// Annual Leave (transferType == "annual-leave") → triggers 'update' transition (add new advisor, keep old).
+/// </summary>
+public class ExecutePermanentChatRoomUpdateMapping : ScriptBase, IMapping
+{
+    public Task<ScriptResponse> InputHandler(WorkflowTask task, ScriptContext context)
+    {
+        var triggerTask = task as DirectTriggerTask;
+        if (triggerTask == null)
+            throw new InvalidOperationException("Task must be a DirectTriggerTask");
+
+        var data = context.Instance?.Data;
+        if (data == null)
+            throw new InvalidOperationException("Instance data is required");
+
+        var permanentRoomPlan = data.permanentRoomPlan;
+        if (permanentRoomPlan == null)
+            return Task.FromResult(new ScriptResponse { Data = new { skipped = true, reason = "no-permanentRoomPlan" } });
+
+        int processedIndex = 0;
+        if (HasProperty(data, "permanentProcessedIndex"))
+            int.TryParse(data.permanentProcessedIndex?.ToString() ?? "0", out processedIndex);
+
+        var items = permanentRoomPlan as IEnumerable<object>;
+        if (items == null)
+            return Task.FromResult(new ScriptResponse { Data = new { skipped = true } });
+
+        var itemsList = items.ToList();
+        if (processedIndex >= itemsList.Count)
+            return Task.FromResult(new ScriptResponse { Data = new { skipped = true } });
+
+        dynamic currentItem = itemsList[processedIndex];
+        var chatRoomKey = currentItem?.chatRoomKey?.ToString();
+        var targetAdvisor = currentItem?.targetAdvisor?.ToString();
+
+        if (string.IsNullOrEmpty(chatRoomKey) || string.IsNullOrEmpty(targetAdvisor))
+            return Task.FromResult(new ScriptResponse { Data = new { skipped = true } });
+
+        var transferType = GetString(data, "transferType");
+
+        triggerTask.SetDomain("touch");
+        triggerTask.SetFlow("chat-room");
+        triggerTask.SetKey(chatRoomKey);
+
+        if (transferType == "termination")
+        {
+            triggerTask.SetTransitionName("transfer");
+            triggerTask.SetBody(new { newAdvisorId = targetAdvisor });
+        }
+        else
+        {
+            triggerTask.SetTransitionName("update");
+            triggerTask.SetBody(new { newMemberId = targetAdvisor });
+        }
+
+        return Task.FromResult(new ScriptResponse());
+    }
+
+    public Task<ScriptResponse> OutputHandler(ScriptContext context)
+    {
+        var data = context.Instance?.Data;
+        var success = context.Body?.isSuccess == true;
+
+        int processedIndex = 0;
+        if (data != null && HasProperty(data, "permanentProcessedIndex"))
+            int.TryParse(data.permanentProcessedIndex?.ToString() ?? "0", out processedIndex);
+
+        var result = new Dictionary<string, object>();
+        CopyIfPresent(result, data, "transferPlan");
+        CopyIfPresent(result, data, "validationResult");
+        CopyIfPresent(result, data, "sourceAdvisorId");
+        CopyIfPresent(result, data, "advisorType");
+        CopyIfPresent(result, data, "startDate");
+        CopyIfPresent(result, data, "endDate");
+        CopyIfPresent(result, data, "transferType");
+        CopyIfPresent(result, data, "enrichedRezervations");
+        CopyIfPresent(result, data, "rezChatRoomPlan");
+        CopyIfPresent(result, data, "permanentRoomPlan");
+        CopyIfPresent(result, data, "permanentChatRooms");
+        result["permanentProcessedIndex"] = processedIndex + 1;
+        result["lastPermanentChatRoomSuccess"] = success;
+
+        return Task.FromResult(new ScriptResponse { Data = result });
+    }
+
+    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 void CopyIfPresent(Dictionary<string, object> target, dynamic source, string name)
+    {
+        if (source == null) return;
+        try
+        {
+            if (HasProperty(source, name))
+            {
+                var v = GetPropertyValue(source, name);
+                if (v != null) target[name] = v;
+            }
+        }
+        catch { }
+    }
+}