@burgan-tech/morph-touch-runtime 0.0.2

package/touch/Functions/src/GetAvailableSlotsMapping.csx

@@ -0,0 +1,468 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using BBT.Workflow.Scripting;
+using BBT.Workflow.Definitions;
+/// <summary>
+/// Mapping for GetAvailableSlotsTask (DaprServiceTask - Type 3)
+/// Queries absence-entry workflow (state: complete) via Dapr service invocation to get
+/// public holidays, working hours changes, and personal leaves.
+/// Then calculates available appointment slots for the given advisor and date.
+///
+/// Working hours priority: advisor-specific > company-wide (advisor=null) > no hours
+/// Half-day public holidays only block the holiday hours, not the entire day.
+/// </summary>
+public class GetAvailableSlotsMapping : 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 advisorId = context.QueryParameters?["advisorId"]?.ToString();
+        var date = context.QueryParameters?["date"]?.ToString();
+
+        if (string.IsNullOrEmpty(advisorId) || string.IsNullOrEmpty(date))
+        {
+            return Task.FromResult(new ScriptResponse
+            {
+                Key = "validation-error",
+                Data = new
+                {
+                    error = "advisorId and date are required",
+                    errorCode = "VALIDATION_ERROR"
+                }
+            });
+        }
+
+        var requestedDate = DateTime.Parse(date);
+        if (requestedDate.Date < DateTime.UtcNow.Date)
+            throw new ArgumentException("Date cannot be in the past.", "date");
+
+        var filterJson =
+            "{\"and\":[" +
+            "{\"or\":[{\"currentState\":{\"eq\":\"complete\"}},{\"currentState\":{\"eq\":\"complete-with-transfer\"}}]}," +
+            "{\"or\":[" +
+                "{\"attributes\":{\"advisor\":{\"eq\":\"" + advisorId + "\"}}}," +
+                "{\"attributes\":{\"absenceType\":{\"eq\":\"public-holiday\"}}}," +
+                "{\"attributes\":{\"absenceType\":{\"eq\":\"working-hours-change\"}}}" +
+            "]}" +
+            "]}";
+
+        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 advisorId = context.QueryParameters?["advisorId"]?.ToString();
+            var dateStr = context.QueryParameters?["date"]?.ToString();
+            var duration = GetAppointmentDuration(context);
+
+            if (string.IsNullOrEmpty(advisorId) || string.IsNullOrEmpty(dateStr))
+            {
+                return Task.FromResult(new ScriptResponse
+                {
+                    Key = "validation-error",
+                    Data = new
+                    {
+                        error = "advisorId and date are required",
+                        errorCode = "VALIDATION_ERROR",
+                        advisorId,
+                        date = dateStr
+                    }
+                });
+            }
+
+            var requestedDate = DateTime.Parse(dateStr);
+            var dayOfWeek = requestedDate.DayOfWeek.ToString().ToLower();
+
+            var response = context.Body;
+
+            if (response?.isSuccess == false)
+            {
+                var errorType = ClassifyServiceError(response?.errorMessage?.ToString() ?? "");
+                return Task.FromResult(new ScriptResponse
+                {
+                    Key = "service-error",
+                    Data = new
+                    {
+                        error = "Failed to fetch absence entries",
+                        errorCode = "SERVICE_ERROR",
+                        errorType = errorType,
+                        errorMessage = response?.errorMessage?.ToString(),
+                        serviceInfo = new
+                        {
+                            appId = response?.metadata?.appId?.ToString(),
+                            methodName = response?.metadata?.methodName?.ToString(),
+                            httpVerb = response?.metadata?.httpVerb?.ToString()
+                        }
+                    },
+                    Tags = new[] { "appointments", "error" }
+                });
+            }
+
+            var responseData = response?.data;
+            var items = responseData?.items;
+
+            var instances = new List<dynamic>();
+            if (items != null)
+            {
+                foreach (var item in items)
+                {
+                    instances.Add(item);
+                }
+            }
+
+            var publicHolidays = new List<dynamic>();
+            var advisorWorkingHours = new List<dynamic>();
+            var companyWorkingHours = new List<dynamic>();
+            var personalLeaves = new List<dynamic>();
+
+            foreach (var instance in instances)
+            {
+                var attributes = instance?.attributes;
+                if (attributes == null) continue;
+
+                var absenceType = attributes?.absenceType?.ToString();
+                var advisor = HasProperty(attributes, "advisor") ? attributes?.advisor?.ToString() : null;
+
+                switch (absenceType)
+                {
+                    case "public-holiday":
+                        publicHolidays.Add(instance);
+                        break;
+                    case "working-hours-change":
+                        if (!string.IsNullOrEmpty(advisor) && advisor == advisorId)
+                            advisorWorkingHours.Add(instance);
+                        else if (string.IsNullOrEmpty(advisor))
+                            companyWorkingHours.Add(instance);
+                        break;
+                    case "personal-leave" when advisor == advisorId:
+                        personalLeaves.Add(instance);
+                        break;
+                    case "rezervation" when advisor == advisorId:
+                        personalLeaves.Add(instance);
+                        break;
+                }
+            }
+
+            var unavailableRanges = GetUnavailableRanges(personalLeaves, requestedDate);
+
+            // Half-day / full-day public holiday handling
+            var holidayRanges = GetHolidayRanges(publicHolidays, requestedDate);
+            if (holidayRanges != null)
+            {
+                if (holidayRanges.Count == 1
+                    && holidayRanges[0].Item1 == TimeSpan.Zero
+                    && holidayRanges[0].Item2 >= new TimeSpan(23, 59, 0))
+                {
+                    return Task.FromResult(new ScriptResponse
+                    {
+                        Key = "public-holiday",
+                        Data = new { availableSlots = new List<string>() },
+                        Tags = new[] { "appointments", "holiday" }
+                    });
+                }
+
+                unavailableRanges.AddRange(holidayRanges);
+            }
+
+            // Working hours priority: advisor-specific > company-wide
+            var workingHours = GetWorkingHoursForDay(advisorWorkingHours, dayOfWeek);
+            if (workingHours == null || workingHours.Count == 0)
+                workingHours = GetWorkingHoursForDay(companyWorkingHours, dayOfWeek);
+
+            if (workingHours == null || workingHours.Count == 0)
+            {
+                return Task.FromResult(new ScriptResponse
+                {
+                    Key = "no-working-hours",
+                    Data = new { availableSlots = new List<string>() },
+                    Tags = new[] { "appointments", "closed" }
+                });
+            }
+
+            var availableSlots = CalculateAvailableSlots(workingHours, unavailableRanges, duration);
+
+            return Task.FromResult(new ScriptResponse
+            {
+                Key = "available-slots-success",
+                Data = new { availableSlots },
+                Tags = new[] { "appointments", "availability", "success" }
+            });
+        }
+        catch (Exception ex)
+        {
+            return Task.FromResult(new ScriptResponse
+            {
+                Key = "output-error",
+                Data = new
+                {
+                    error = "Internal processing error",
+                    errorCode = "PROCESSING_ERROR",
+                    errorDescription = ex.Message
+                },
+                Tags = new[] { "appointments", "error" }
+            });
+        }
+    }
+
+    #region Helper Methods
+
+    private string ClassifyServiceError(string errorMessage)
+    {
+        if (errorMessage.Contains("timeout", StringComparison.OrdinalIgnoreCase))
+            return "timeout";
+        if (errorMessage.Contains("unauthorized", StringComparison.OrdinalIgnoreCase))
+            return "authentication";
+        if (errorMessage.Contains("forbidden", StringComparison.OrdinalIgnoreCase))
+            return "authorization";
+        if (errorMessage.Contains("not found", StringComparison.OrdinalIgnoreCase))
+            return "not-found";
+        if (errorMessage.Contains("service unavailable", StringComparison.OrdinalIgnoreCase))
+            return "service-unavailable";
+        if (errorMessage.Contains("connection", StringComparison.OrdinalIgnoreCase))
+            return "connection-error";
+
+        return "general-error";
+    }
+
+    private int GetAppointmentDuration(ScriptContext context)
+    {
+        const int defaultDuration = 30;
+
+        if (context.QueryParameters != null && HasProperty(context.QueryParameters, "duration"))
+        {
+            var durationParam = context.QueryParameters["duration"];
+            int queryDuration = 0;
+            if (durationParam != null && int.TryParse(durationParam.ToString(), out queryDuration))
+            {
+                return queryDuration;
+            }
+        }
+
+        var configDuration = GetConfigValue("Appointments:DefaultDuration");
+        int configDurationValue = 0;
+        if (!string.IsNullOrEmpty(configDuration) && int.TryParse(configDuration, out configDurationValue))
+        {
+            return configDurationValue;
+        }
+
+        return defaultDuration;
+    }
+
+    #endregion
+
+    #region Business Logic Methods
+
+    /// <summary>
+    /// Returns unavailable time ranges for public holidays on the requested date.
+    /// null = no holiday on this date.
+    /// Full-day holiday: single range 00:00-23:59.
+    /// Half-day holiday: partial range (e.g., 00:00-13:00).
+    /// </summary>
+    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 = null;
+            string endDateTimeStr = null;
+
+            if (HasProperty(holidayData, "startDateTime") && holidayData.startDateTime != null)
+                startDateTimeStr = holidayData.startDateTime.ToString();
+
+            if (HasProperty(holidayData, "endDateTime") && holidayData.endDateTime != null)
+                endDateTimeStr = holidayData.endDateTime.ToString();
+
+            if (string.IsNullOrEmpty(startDateTimeStr) || string.IsNullOrEmpty(endDateTimeStr))
+                continue;
+
+            var startDateTime = DateTime.Parse(startDateTimeStr);
+            var endDateTime = DateTime.Parse(endDateTimeStr);
+
+            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)
+    {
+        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 = null;
+            string endDateTimeStr = null;
+
+            if (HasProperty(leaveData, "startDateTime") && leaveData.startDateTime != null)
+                startDateTimeStr = leaveData.startDateTime.ToString();
+
+            if (HasProperty(leaveData, "endDateTime") && leaveData.endDateTime != null)
+                endDateTimeStr = leaveData.endDateTime.ToString();
+
+            if (string.IsNullOrEmpty(startDateTimeStr) || string.IsNullOrEmpty(endDateTimeStr))
+                continue;
+
+            var startDateTime = DateTime.Parse(startDateTimeStr);
+            var endDateTime = DateTime.Parse(endDateTimeStr);
+
+            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;
+    }
+
+    private List<string> CalculateAvailableSlots(List<object> workingHours, List<Tuple<TimeSpan, TimeSpan>> unavailableRanges, int durationMinutes)
+    {
+        var slots = new List<string>();
+        var duration = TimeSpan.FromMinutes(durationMinutes);
+
+        foreach (var wh in workingHours)
+        {
+            dynamic whDyn = wh;
+            var startStr = whDyn?.start?.ToString();
+            var endStr = whDyn?.end?.ToString();
+
+            if (string.IsNullOrEmpty(startStr) || string.IsNullOrEmpty(endStr))
+                continue;
+
+            var whStart = TimeSpan.Parse(startStr);
+            var whEnd = TimeSpan.Parse(endStr);
+
+            if (whStart == whEnd)
+                continue;
+
+            var current = whStart;
+            while (current + duration <= whEnd)
+            {
+                var slotStart = current;
+                var slotEnd = current + duration;
+
+                bool isAvailable = true;
+                foreach (var ur in unavailableRanges)
+                {
+                    if (slotStart < ur.Item2 && slotEnd > ur.Item1)
+                    {
+                        isAvailable = false;
+                        break;
+                    }
+                }
+
+                if (isAvailable)
+                {
+                    slots.Add($"{slotStart:hh\\:mm}-{slotEnd:hh\\:mm}");
+                }
+
+                current = current + duration;
+            }
+        }
+
+        return slots;
+    }
+
+    #endregion
+}

package/touch/Functions/src/GetChatRoomsMapping.csx

@@ -0,0 +1,202 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using BBT.Workflow.Scripting;
+using BBT.Workflow.Definitions;
+
+/// <summary>
+/// Mapping for query-chat-room-instances DaprServiceTask (Type 3).
+/// Flow-level function (scope: F) -- no instance context.
+/// Reads "user" OR "advisor" from query parameters (mutually exclusive).
+/// For advisor: server filter advisorId=X OR members contains { role: "member", memberId: X }.
+/// For user: returns rooms where user=X (server-side filter).
+/// </summary>
+public class GetChatRoomsMapping : 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 user = ReadParam(context, "user");
+        var advisor = ReadParam(context, "advisor");
+
+        bool hasUser = !string.IsNullOrWhiteSpace(user);
+        bool hasAdvisor = !string.IsNullOrWhiteSpace(advisor);
+
+        if (hasUser && hasAdvisor)
+            throw new InvalidOperationException("VALIDATION_ERROR: user and advisor are mutually exclusive, provide only one");
+
+        if (!hasUser && !hasAdvisor)
+            throw new InvalidOperationException("VALIDATION_ERROR: either user or advisor query parameter is required");
+
+        string attributeFilter;
+        if (hasUser)
+        {
+            var escaped = user.Replace("\\", "\\\\").Replace("\"", "\\\"");
+            attributeFilter = "{\"attributes\":{\"user\":{\"eq\":\"" + escaped + "\"}}}";
+        }
+        else
+        {
+            var escaped = advisor.Replace("\\", "\\\\").Replace("\"", "\\\"");
+            attributeFilter = "{\"attributes\":{\"advisorId\":{\"eq\":\"" + escaped + "\"}}}";
+
+            // attributeFilter = "{\"or\":[" +
+            //     "{\"attributes\":{\"advisorId\":{\"eq\":\"" + escaped + "\"}}}," +
+            //     "{\"attributes\":{\"members\":{\"contains\":{\"role\":\"member\",\"memberId\":\"" + escaped + "\"}}}" +
+            //     "]}";
+        }
+
+        var roomType = ReadParam(context, "roomType");
+        if (!string.IsNullOrWhiteSpace(roomType))
+        {
+            var escapedType = roomType.Replace("\\", "\\\\").Replace("\"", "\\\"");
+            attributeFilter = "{\"and\":[" + attributeFilter + ",{\"attributes\":{\"roomType\":{\"eq\":\"" + escapedType + "\"}}}]}";
+        }
+
+        var state = ReadParam(context, "state");
+        string stateFilter;
+        if (string.IsNullOrWhiteSpace(state))
+        {
+            stateFilter = "{\"or\":[{\"currentState\":{\"eq\":\"activated\"}},{\"currentState\":{\"eq\":\"deactivated\"}}]}";
+        }
+        else
+        {
+            var escapedState = state.Replace("\\", "\\\\").Replace("\"", "\\\"");
+            stateFilter = "{\"currentState\":{\"eq\":\"" + escapedState + "\"}}";
+        }
+
+        var filterBody = "{\"and\":[" + attributeFilter + "," + stateFilter + "]}";
+        var queryParams = new List<string>
+        {
+            "pageSize=100",
+            "filter=" + filterBody
+        };
+
+        serviceTask.SetQueryString(string.Join("&", queryParams));
+
+        return Task.FromResult(new ScriptResponse());
+    }
+
+    public Task<ScriptResponse> OutputHandler(ScriptContext context)
+    {
+        try
+        {
+            var response = context.Body;
+
+            if (response?.isSuccess == false)
+            {
+                var errorMessage = response?.errorMessage?.ToString() ?? "Service call failed";
+                return Task.FromResult(new ScriptResponse
+                {
+                    Key = "get-chat-rooms-failure",
+                    Data = new
+                    {
+                        error = errorMessage,
+                        errorCode = "SERVICE_ERROR",
+                        rooms = new List<object>()
+                    },
+                    Tags = new[] { "chat", "rooms", "error" }
+                });
+            }
+
+            var responseData = response?.data;
+            var items = responseData?.items;
+            var rooms = new List<object>();
+
+            if (items != null)
+            {
+                foreach (var item in items)
+                {
+                    // Runtime may expose instance payload as "attributes" or "data"
+                    var attributes = item?.attributes ?? item?.data;
+                    if (attributes == null) continue;
+
+                    var metadata = item?.metadata;
+                    string currentState = metadata != null ? GetString(metadata, "currentState") : null;
+
+                    string roomId = null;
+                    if (HasProperty(attributes, "chatIntegration") && attributes.chatIntegration != null)
+                        roomId = GetString(attributes.chatIntegration, "roomId");
+
+                    var members = new List<object>();
+                    if (HasProperty(attributes, "members") && attributes.members != null)
+                    {
+                        foreach (var m in attributes.members)
+                        {
+                            var mid = GetString(m, "memberId") ?? GetString(m, "advisorId");
+                            members.Add(new { memberId = mid, role = GetString(m, "role") });
+                        }
+                    }
+
+                    var instanceKey = GetString(item, "key");
+                    rooms.Add(new
+                    {
+                        id = GetString(item, "id") ?? instanceKey,
+                        instanceKey = instanceKey,
+                        user = GetString(attributes, "user"),
+                        advisorType = GetString(attributes, "advisorType"),
+                        advisorId = GetString(attributes, "advisorId"),
+                        roomId = roomId,
+                        status = GetString(attributes, "status"),
+                        roomType = GetString(attributes, "roomType"),
+                        startDateTime = GetString(attributes, "startDateTime"),
+                        endDateTime = GetString(attributes, "endDateTime"),
+                        members = members,
+                        metadata = currentState != null ? new { currentState } : null
+                    });
+                }
+            }
+
+            return Task.FromResult(new ScriptResponse
+            {
+                Key = "get-chat-rooms-success",
+                Data = new { rooms = rooms },
+                Tags = new[] { "chat", "rooms", "success" }
+            });
+        }
+        catch (Exception ex)
+        {
+            return Task.FromResult(new ScriptResponse
+            {
+                Key = "get-chat-rooms-error",
+                Data = new
+                {
+                    error = "Internal processing error",
+                    errorCode = "PROCESSING_ERROR",
+                    errorDescription = ex.Message,
+                    rooms = new List<object>()
+                },
+                Tags = new[] { "chat", "rooms", "error" }
+            });
+        }
+    }
+
+    private string ReadParam(ScriptContext context, string name)
+    {
+        if (context.QueryParameters == null || !HasProperty(context.QueryParameters, name))
+            return null;
+        var val = context.QueryParameters[name];
+        return val != null ? val.ToString() : null;
+    }
+
+    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;
+    }
+}