@burgan-tech/morph-touch-runtime 0.0.2

package/touch/Functions/src/GetCustomerInfoMapping.csx

@@ -0,0 +1,140 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using BBT.Workflow.Scripting;
+using BBT.Workflow.Definitions;
+/// <summary>
+/// Mapping for GetCustomerInfoTask (DaprServiceTask - Type 3)
+/// Fetches customer information (name, surname, segment) from the UserSegmentBaseUrl endpoint.
+///
+/// Query parameters:
+///   - customerId (required): customer identifier (TCKN or customer number)
+///
+/// The task calls the external API configured via UserSegmentBaseUrl secret in Vault.
+/// </summary>
+public class GetCustomerInfoMapping : ScriptBase, IMapping
+{
+    public async Task<ScriptResponse> InputHandler(WorkflowTask task, ScriptContext context)
+    {
+        var serviceTask = task as DaprServiceTask;
+        if (serviceTask == null)
+            throw new InvalidOperationException("Task must be a DaprServiceTask");
+
+        var customerId = ReadParam(context, "customerId");
+        if (string.IsNullOrEmpty(customerId))
+        {
+            return new ScriptResponse
+            {
+                Key = "validation-error",
+                Data = new
+                {
+                    error = "customerId is required",
+                    errorCode = "VALIDATION_ERROR"
+                }
+            };
+        }
+
+        var secretStore = context.DaprClient;
+        string baseUrl = "";
+        try
+        {
+            var secrets = await secretStore.GetSecretAsync("vault", "UserSegmentBaseUrl");
+            if (secrets != null && secrets.ContainsKey("UserSegmentBaseUrl"))
+                baseUrl = secrets["UserSegmentBaseUrl"];
+        }
+        catch
+        {
+            return new ScriptResponse
+            {
+                Key = "config-error",
+                Data = new
+                {
+                    error = "UserSegmentBaseUrl secret not configured in Vault",
+                    errorCode = "CONFIG_ERROR"
+                }
+            };
+        }
+
+        if (string.IsNullOrEmpty(baseUrl))
+        {
+            return new ScriptResponse
+            {
+                Key = "config-error",
+                Data = new
+                {
+                    error = "UserSegmentBaseUrl is empty or not found",
+                    errorCode = "CONFIG_ERROR"
+                }
+            };
+        }
+
+        serviceTask.SetUrl(baseUrl);
+        serviceTask.SetQueryString($"customerId={customerId}");
+
+        return new ScriptResponse();
+    }
+
+    public Task<ScriptResponse> OutputHandler(ScriptContext context)
+    {
+        try
+        {
+            var customerId = ReadParam(context, "customerId");
+            var response = context.Body;
+
+            if (response?.isSuccess == false)
+            {
+                return Task.FromResult(new ScriptResponse
+                {
+                    Key = "service-error",
+                    Data = new
+                    {
+                        error = "Failed to fetch customer info",
+                        errorCode = "SERVICE_ERROR",
+                        errorMessage = response?.errorMessage?.ToString()
+                    },
+                    Tags = new[] { "customer-info", "error" }
+                });
+            }
+
+            var data = response?.data ?? response;
+
+            return Task.FromResult(new ScriptResponse
+            {
+                Key = "customer-info-success",
+                Data = new
+                {
+                    customerId,
+                    name = data?.name?.ToString() ?? data?.firstName?.ToString() ?? "",
+                    surname = data?.surname?.ToString() ?? data?.lastName?.ToString() ?? "",
+                    segment = data?.segment?.ToString() ?? "",
+                    channelSegment = data?.channelSegment?.ToString() ?? "",
+                    email = data?.email?.ToString() ?? "",
+                    phone = data?.phone?.ToString() ?? ""
+                },
+                Tags = new[] { "customer-info", "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[] { "customer-info", "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;
+    }
+}

package/touch/Functions/src/GetMatrixSyncMapping.csx

@@ -0,0 +1,197 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using BBT.Workflow.Scripting;
+using BBT.Workflow.Definitions;
+
+/// <summary>
+/// Mapping for get-matrix-sync HttpTask (Type 6).
+/// Flow-level function (scope: F) -- no instance context.
+/// Reads user, since, timeout, roomId from query parameters.
+/// Calls GET /_matrix/client/v3/sync via APISIX. Supports long polling.
+/// Returns next_batch token and eventsByRoom (m.room.message events per room).
+/// </summary>
+public class GetMatrixSyncMapping : ScriptBase, IMapping
+{
+    public async Task<ScriptResponse> InputHandler(WorkflowTask task, ScriptContext context)
+    {
+        var httpTask = task as HttpTask;
+        if (httpTask == null)
+            throw new InvalidOperationException("Task must be an HttpTask");
+
+        var matrixBaseUrl = await GetSecretAsync("vnext-secret", "workflow-secret", "MatrixBaseUrl");
+        if (string.IsNullOrWhiteSpace(matrixBaseUrl))
+            throw new InvalidOperationException("MatrixBaseUrl secret is required");
+
+        var user = ReadParam(context, "user");
+        if (string.IsNullOrWhiteSpace(user))
+            throw new InvalidOperationException("VALIDATION_ERROR: user query parameter is required");
+
+        var since = ReadParam(context, "since");
+        var timeout = ReadParam(context, "timeout");
+        if (string.IsNullOrWhiteSpace(timeout))
+            timeout = "30000";
+
+        var roomId = ReadParam(context, "roomId");
+
+        var qs = "timeout=" + Uri.EscapeDataString(timeout);
+        if (!string.IsNullOrWhiteSpace(since))
+            qs += "&since=" + Uri.EscapeDataString(since);
+        if (!string.IsNullOrWhiteSpace(roomId))
+        {
+            var filter = "{\"room\":{\"rooms\":[\"" + roomId.Replace("\\", "\\\\").Replace("\"", "\\\"") + "\"]}}";
+            qs += "&filter=" + Uri.EscapeDataString(filter);
+        }
+
+        var fullUrl = matrixBaseUrl.TrimEnd('/') + "/_matrix/client/v3/sync?" + qs;
+        httpTask.SetUrl(fullUrl);
+
+        var headers = new Dictionary<string, string>
+        {
+            ["Accept"] = "application/json",
+            ["X-Matrix-User"] = user
+        };
+        httpTask.SetHeaders(headers);
+
+        return new ScriptResponse();
+    }
+
+    public Task<ScriptResponse> OutputHandler(ScriptContext context)
+    {
+        try
+        {
+            var response = context.Body;
+            var bodyData = response?.data;
+
+            string errcode = GetString(bodyData, "errcode");
+            if (!string.IsNullOrEmpty(errcode))
+            {
+                string errorMsg = GetString(bodyData, "error");
+                return Task.FromResult(new ScriptResponse
+                {
+                    Key = "get-matrix-sync-error",
+                    Data = new
+                    {
+                        error = errorMsg,
+                        errorCode = errcode,
+                        nextBatch = (string)null,
+                        eventsByRoom = new Dictionary<string, List<object>>()
+                    },
+                    Tags = new[] { "chat", "sync", "error" }
+                });
+            }
+
+            string nextBatch = GetString(bodyData, "next_batch");
+            var eventsByRoom = new Dictionary<string, List<object>>();
+
+            var rooms = GetPropertyValue(bodyData, "rooms");
+            if (rooms != null && HasProperty(rooms, "join"))
+            {
+                var join = GetPropertyValue(rooms, "join");
+                if (join != null)
+                {
+                    try
+                    {
+                        foreach (dynamic kv in (System.Collections.IEnumerable)join)
+                        {
+                            string rId = kv.Key?.ToString();
+                            if (string.IsNullOrWhiteSpace(rId)) continue;
+
+                            dynamic roomData = kv.Value;
+                            if (roomData == null) continue;
+
+                            var timeline = roomData.timeline;
+                            if (timeline == null) continue;
+
+                            var events = timeline.events;
+                            if (events == null) continue;
+
+                            var msgList = new List<object>();
+                            foreach (var evt in events)
+                            {
+                                var evtType = GetString(evt, "type");
+                                if (evtType != "m.room.message") continue;
+
+                                var content = GetPropertyValue(evt, "content");
+                                if (content == null) continue;
+
+                                string body = GetString(content, "body");
+                                string msgtype = GetString(content, "msgtype");
+                                string sender = GetString(evt, "sender");
+                                string eventId = GetString(evt, "event_id");
+                                var tsObj = GetPropertyValue(evt, "origin_server_ts");
+                                string ts = tsObj != null ? tsObj.ToString() : null;
+
+                                msgList.Add(new
+                                {
+                                    eventId = eventId,
+                                    sender = sender,
+                                    body = body,
+                                    timestamp = ts,
+                                    msgtype = msgtype ?? "m.text"
+                                });
+                            }
+
+                            if (msgList.Count > 0)
+                                eventsByRoom[rId] = msgList;
+                        }
+                    }
+                    catch (Exception)
+                    {
+                        // Fallback: join may have different structure
+                    }
+                }
+            }
+
+            return Task.FromResult(new ScriptResponse
+            {
+                Key = "get-matrix-sync-success",
+                Data = new
+                {
+                    nextBatch = nextBatch,
+                    eventsByRoom = eventsByRoom
+                },
+                Tags = new[] { "chat", "sync", "success" }
+            });
+        }
+        catch (Exception ex)
+        {
+            return Task.FromResult(new ScriptResponse
+            {
+                Key = "get-matrix-sync-error",
+                Data = new
+                {
+                    error = "Internal processing error",
+                    errorCode = "PROCESSING_ERROR",
+                    errorDescription = ex.Message,
+                    nextBatch = (string)null,
+                    eventsByRoom = new Dictionary<string, List<object>>()
+                },
+                Tags = new[] { "chat", "sync", "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;
+    }
+}

package/touch/Functions/src/GetRezervationsMapping.csx

@@ -0,0 +1,162 @@
+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 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.
+/// 
+/// Reference: https://github.com/burgan-tech/vnext-runtime/blob/main/doc/en/flow/tasks/dapr-service.md
+/// </summary>
+public class GetRezervationsMapping : 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);
+
+        // Read parameters from query string (GET request)
+        var advisorId = context.QueryParameters != null && HasProperty(context.QueryParameters, "advisorId") ? context.QueryParameters?["advisorId"]?.ToString() : string.Empty;
+        var userId = context.QueryParameters != null && HasProperty(context.QueryParameters, "userId") ? context.QueryParameters?["userId"]?.ToString() : string.Empty;
+        var managerId = context.QueryParameters != null && HasProperty(context.QueryParameters, "managerId") ? context.QueryParameters?["managerId"]?.ToString() : string.Empty;
+        var startDate = context.QueryParameters != null && HasProperty(context.QueryParameters, "startDate") ? context.QueryParameters?["startDate"]?.ToString() : string.Empty;
+        var endDate = context.QueryParameters != null && HasProperty(context.QueryParameters, "endDate") ? context.QueryParameters?["endDate"]?.ToString() : string.Empty;
+
+        // Build filter conditions
+        var conditions = new List<string>();
+
+        // CurrentState in ("active", "can-start-meeting", "accept-terms")
+        conditions.Add(
+            "{\"or\":[" +
+            "{\"currentState\":{\"eq\":\"active\"}}," +
+            "{\"currentState\":{\"eq\":\"in-meet\"}}," +
+            "{\"currentState\":{\"eq\":\"accept-terms\"}}" +
+            "]}");
+
+        // Status = "A"
+        conditions.Add("{\"status\":{\"eq\":\"A\"}}");
+
+        // Conditional: advisor filter
+        if (!string.IsNullOrEmpty(advisorId))
+            conditions.Add("{\"attributes\":{\"advisor\":{\"eq\":\"" + advisorId + "\"}}}");
+
+        // Conditional: user filter
+        if (!string.IsNullOrEmpty(userId))
+            conditions.Add("{\"attributes\":{\"user\":{\"eq\":\"" + userId + "\"}}}");
+
+        // Conditional: manager filter
+        if (!string.IsNullOrEmpty(managerId))
+            conditions.Add("{\"attributes\":{\"manager\":{\"eq\":\"" + managerId + "\"}}}");
+
+        // Conditional: startDate filter (attributes.startDateTime >= startDate)
+        if (!string.IsNullOrEmpty(startDate))
+            conditions.Add("{\"attributes\":{\"startDateTime\":{\"gte\":\"" + startDate + "\"}}}");
+
+        // Conditional: endDate filter (attributes.endDateTime <= endDate)
+        if (!string.IsNullOrEmpty(endDate))
+            conditions.Add("{\"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 response = context.Body;
+
+            // Check if service call was successful
+            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" }
+                });
+            }
+
+            // Get items from service response
+            // Response structure: { data: { items: [...] }, isSuccess: true, ... }
+            var responseData = response?.data;
+            var items = responseData?.items;
+
+            return Task.FromResult(new ScriptResponse
+            {
+                Key = "rezervations-success",
+                Data = new
+                {
+                    items
+                },
+                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";
+    }
+
+    #endregion
+}

package/touch/Functions/src/GetRoomMessagesMapping.csx

@@ -0,0 +1,165 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using BBT.Workflow.Scripting;
+using BBT.Workflow.Definitions;
+
+/// <summary>
+/// Mapping for get-matrix-room-messages HttpTask (Type 6).
+/// Flow-level function (scope: F) -- no instance context.
+/// Reads roomId, user, limit, from query parameters.
+/// Calls GET /_matrix/client/v3/rooms/{roomId}/messages via APISIX.
+/// Returns structured message list from Matrix response.
+/// </summary>
+public class GetRoomMessagesMapping : ScriptBase, IMapping
+{
+    public async Task<ScriptResponse> InputHandler(WorkflowTask task, ScriptContext context)
+    {
+        var httpTask = task as HttpTask;
+        if (httpTask == null)
+            throw new InvalidOperationException("Task must be an HttpTask");
+
+        var matrixBaseUrl = await GetSecretAsync("vnext-secret", "workflow-secret", "MatrixBaseUrl");
+        if (string.IsNullOrWhiteSpace(matrixBaseUrl))
+            throw new InvalidOperationException("MatrixBaseUrl secret is required");
+
+        var roomId = ReadParam(context, "roomId");
+        var user = ReadParam(context, "user");
+
+        if (string.IsNullOrWhiteSpace(roomId))
+            throw new InvalidOperationException("VALIDATION_ERROR: roomId query parameter is required");
+        if (string.IsNullOrWhiteSpace(user))
+            throw new InvalidOperationException("VALIDATION_ERROR: user query parameter is required");
+
+        var limit = ReadParam(context, "limit");
+        if (string.IsNullOrWhiteSpace(limit))
+            limit = "50";
+
+        var from = ReadParam(context, "from");
+
+        var fullUrl = matrixBaseUrl.TrimEnd('/') + "/_matrix/client/v3/rooms/" + Uri.EscapeDataString(roomId) + "/messages";
+
+        var qs = "dir=b&limit=" + limit;
+        if (!string.IsNullOrWhiteSpace(from))
+            qs += "&from=" + Uri.EscapeDataString(from);
+
+        httpTask.SetUrl(fullUrl + "?" + qs);
+
+        var headers = new Dictionary<string, string>
+        {
+            ["Accept"] = "application/json",
+            ["X-Matrix-User"] = user
+        };
+        httpTask.SetHeaders(headers);
+
+        return new ScriptResponse();
+    }
+
+    public Task<ScriptResponse> OutputHandler(ScriptContext context)
+    {
+        try
+        {
+            var response = context.Body;
+            var bodyData = response?.data;
+
+            string errcode = GetString(bodyData, "errcode");
+            if (!string.IsNullOrEmpty(errcode))
+            {
+                string errorMsg = GetString(bodyData, "error");
+                return Task.FromResult(new ScriptResponse
+                {
+                    Key = "get-room-messages-error",
+                    Data = new
+                    {
+                        error = errorMsg,
+                        errorCode = errcode,
+                        messages = new List<object>()
+                    },
+                    Tags = new[] { "chat", "messages", "error" }
+                });
+            }
+
+            var messages = new List<object>();
+
+            if (HasProperty(bodyData, "chunk") && bodyData.chunk != null)
+            {
+                foreach (var evt in bodyData.chunk)
+                {
+                    var evtType = GetString(evt, "type");
+                    if (evtType != "m.room.message") continue;
+
+                    var content = evt?.content;
+                    if (content == null) continue;
+
+                    string body = GetString(content, "body");
+                    string msgtype = GetString(content, "msgtype");
+                    string sender = GetString(evt, "sender");
+                    string eventId = GetString(evt, "event_id");
+                    string ts = GetString(evt, "origin_server_ts");
+
+                    messages.Add(new
+                    {
+                        eventId = eventId,
+                        sender = sender,
+                        body = body,
+                        timestamp = ts,
+                        msgtype = msgtype
+                    });
+                }
+            }
+
+            string nextToken = GetString(bodyData, "end");
+            string prevToken = GetString(bodyData, "start");
+
+            return Task.FromResult(new ScriptResponse
+            {
+                Key = "get-room-messages-success",
+                Data = new
+                {
+                    messages = messages,
+                    nextToken = nextToken,
+                    prevToken = prevToken
+                },
+                Tags = new[] { "chat", "messages", "success" }
+            });
+        }
+        catch (Exception ex)
+        {
+            return Task.FromResult(new ScriptResponse
+            {
+                Key = "get-room-messages-error",
+                Data = new
+                {
+                    error = "Internal processing error",
+                    errorCode = "PROCESSING_ERROR",
+                    errorDescription = ex.Message,
+                    messages = new List<object>()
+                },
+                Tags = new[] { "chat", "messages", "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;
+    }
+}