@burgan-tech/morph-touch-runtime 0.0.2

package/touch/Functions/src/GetAbsenceEntryMapping.csx

@@ -0,0 +1,225 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using BBT.Workflow.Scripting;
+using BBT.Workflow.Definitions;
+/// <summary>
+/// Mapping for GetAbsenceEntryTask (DaprServiceTask - Type 3)
+/// Queries absence-entry workflow instances in complete state, filtered by absenceType.
+///
+/// Query parameters:
+///   - absenceType (required): "public-holiday" | "personal-leave" | "working-hours-change" | "rezervation"
+///   - startDate (optional, public-holiday/personal-leave/rezervation): filter startDateTime >= value
+///   - endDate (optional, public-holiday/personal-leave/rezervation): filter endDateTime <= value
+///   - advisor (optional, personal-leave/working-hours-change/rezervation): filter by advisor
+///   - pageSize (optional, default 100)
+///
+/// Note: Date filtering (startDate/endDate) is performed client-side in OutputHandler
+/// because the platform API does not support gte/lte operators on attribute fields.
+/// </summary>
+public class GetAbsenceEntryMapping : 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 absenceType = ReadParam(context, "absenceType");
+
+        if (string.IsNullOrEmpty(absenceType))
+        {
+            return Task.FromResult(new ScriptResponse
+            {
+                Key = "validation-error",
+                Data = new
+                {
+                    error = "absenceType is required",
+                    errorCode = "VALIDATION_ERROR",
+                    validValues = new[] { "public-holiday", "personal-leave", "working-hours-change", "rezervation" }
+                }
+            });
+        }
+
+        var validTypes = new[] { "public-holiday", "personal-leave", "working-hours-change", "rezervation" };
+        bool isValid = false;
+        foreach (var vt in validTypes)
+        {
+            if (vt == absenceType) { isValid = true; break; }
+        }
+
+        if (!isValid)
+        {
+            return Task.FromResult(new ScriptResponse
+            {
+                Key = "validation-error",
+                Data = new
+                {
+                    error = "Invalid absenceType value",
+                    errorCode = "VALIDATION_ERROR",
+                    provided = absenceType,
+                    validValues = validTypes
+                }
+            });
+        }
+
+        var advisor = ReadParam(context, "advisor");
+
+        var pageSizeStr = ReadParam(context, "pageSize");
+        int pageSize = 100;
+        if (!string.IsNullOrEmpty(pageSizeStr))
+        {
+            int parsed = 0;
+            if (int.TryParse(pageSizeStr, out parsed) && parsed > 0)
+                pageSize = parsed;
+        }
+
+        var conditions = new List<string>();
+
+        conditions.Add("{\"attributes\":{\"absenceType\":{\"eq\":\"" + absenceType + "\"}}}");
+
+        if (absenceType == "working-hours-change")
+        {
+            if (!string.IsNullOrEmpty(advisor))
+                conditions.Add("{\"key\":{\"eq\":\"working-hour-" + advisor + "\"}}");
+            else
+                conditions.Add("{\"key\":{\"eq\":\"working-hour\"}}");
+        }
+
+        if ((absenceType == "personal-leave" || absenceType == "rezervation") && !string.IsNullOrEmpty(advisor))
+            conditions.Add("{\"attributes\":{\"advisor\":{\"eq\":\"" + advisor + "\"}}}");
+
+        var filterJson = "{\"and\":[" + string.Join(",", conditions) + "]}";
+
+        var queryParams = new List<string>
+        {
+            "pageSize=" + pageSize,
+            "currentState=complete",
+            "filter=" + filterJson
+        };
+
+        serviceTask.SetQueryString(string.Join("&", queryParams));
+
+        return Task.FromResult(new ScriptResponse());
+    }
+
+    public async Task<ScriptResponse> OutputHandler(ScriptContext context)
+    {
+        try
+        {
+            var absenceType = ReadParam(context, "absenceType");
+            var response = context.Body;
+
+            if (response?.isSuccess == false)
+            {
+                return new ScriptResponse
+                {
+                    Key = "service-error",
+                    Data = new
+                    {
+                        error = "Failed to fetch absence entries",
+                        errorCode = "SERVICE_ERROR",
+                        errorMessage = response?.errorMessage?.ToString(),
+                        serviceInfo = new
+                        {
+                            appId = response?.metadata?.appId?.ToString(),
+                            methodName = response?.metadata?.methodName?.ToString(),
+                            httpVerb = response?.metadata?.httpVerb?.ToString()
+                        }
+                    },
+                    Tags = new[] { "absence-entry", "error" }
+                };
+            }
+
+            var responseData = response?.data;
+            var items = responseData?.items;
+
+            bool supportsDateFilter = (absenceType == "public-holiday" || absenceType == "personal-leave" || absenceType == "rezervation");
+            var startDateStr = ReadParam(context, "startDate");
+            var endDateStr = ReadParam(context, "endDate");
+
+            if (supportsDateFilter && (!string.IsNullOrEmpty(startDateStr) || !string.IsNullOrEmpty(endDateStr)) && items != null)
+            {
+                DateTime startDateFilter = default;
+                DateTime endDateFilter = default;
+                bool hasStartFilter = !string.IsNullOrEmpty(startDateStr) && DateTime.TryParse(startDateStr, out startDateFilter);
+                bool hasEndFilter = !string.IsNullOrEmpty(endDateStr) && DateTime.TryParse(endDateStr, out endDateFilter);
+
+                var filteredItems = new List<dynamic>();
+                foreach (dynamic item in items)
+                {
+                    var attrs = item?.attributes;
+                    if (attrs == null) continue;
+
+                    string itemStartStr = attrs?.startDateTime?.ToString();
+                    string itemEndStr = attrs?.endDateTime?.ToString();
+
+                    DateTime itemStart = default;
+                    DateTime itemEnd = default;
+                    bool parsedStart = !string.IsNullOrEmpty(itemStartStr) && DateTime.TryParse(itemStartStr, out itemStart);
+                    bool parsedEnd = !string.IsNullOrEmpty(itemEndStr) && DateTime.TryParse(itemEndStr, out itemEnd);
+
+                    bool include = true;
+
+                    if (hasStartFilter && parsedStart && itemStart < startDateFilter)
+                        include = false;
+
+                    if (hasEndFilter && parsedEnd && itemEnd > endDateFilter)
+                        include = false;
+
+                    if (include)
+                        filteredItems.Add(item);
+                }
+
+                return new ScriptResponse
+                {
+                    Key = "absence-entry-success",
+                    Data = new
+                    {
+                        absenceType,
+                        items = filteredItems
+                    },
+                    Tags = new string[] { "absence-entry", absenceType ?? "", "success" }
+                };
+            }
+
+            return new ScriptResponse
+            {
+                Key = "absence-entry-success",
+                Data = new
+                {
+                    absenceType,
+                    items
+                },
+                Tags = new string[] { "absence-entry", absenceType ?? "", "success" }
+            };
+        }
+        catch (Exception ex)
+        {
+            return new ScriptResponse
+            {
+                Key = "output-error",
+                Data = new
+                {
+                    error = "Internal processing error",
+                    errorCode = "PROCESSING_ERROR",
+                    errorDescription = ex.Message
+                },
+                Tags = new[] { "absence-entry", "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/GetAdvisorStatsMapping.csx

@@ -0,0 +1,190 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using BBT.Workflow.Scripting;
+using BBT.Workflow.Definitions;
+/// <summary>
+/// Mapping for GetAdvisorStatsTask (DaprServiceTask - Type 3)
+/// Queries rezervation workflow instances to calculate advisor performance statistics.
+///
+/// Query parameters:
+///   - advisorId (required): advisor identifier
+///   - period (optional): "week" | "month" — default "week"
+///   - startDate (optional): filter startDateTime >= value
+///   - endDate (optional): filter endDateTime <= value
+/// </summary>
+public class GetAdvisorStatsMapping : 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 advisorId = ReadParam(context, "advisorId");
+        if (string.IsNullOrEmpty(advisorId))
+        {
+            return Task.FromResult(new ScriptResponse
+            {
+                Key = "validation-error",
+                Data = new
+                {
+                    error = "advisorId is required",
+                    errorCode = "VALIDATION_ERROR"
+                }
+            });
+        }
+
+        var period = ReadParam(context, "period") ?? "week";
+        var startDate = ReadParam(context, "startDate");
+        var endDate = ReadParam(context, "endDate");
+
+        if (string.IsNullOrEmpty(startDate) || string.IsNullOrEmpty(endDate))
+        {
+            var now = DateTime.UtcNow;
+            if (period == "month")
+            {
+                startDate = startDate ?? now.AddDays(-30).ToString("yyyy-MM-ddTHH:mm:ss");
+                endDate = endDate ?? now.ToString("yyyy-MM-ddTHH:mm:ss");
+            }
+            else
+            {
+                startDate = startDate ?? now.AddDays(-7).ToString("yyyy-MM-ddTHH:mm:ss");
+                endDate = endDate ?? now.ToString("yyyy-MM-ddTHH:mm:ss");
+            }
+        }
+
+        var conditions = new List<string>();
+        conditions.Add("{\"attributes\":{\"advisor\":{\"eq\":\"" + advisorId + "\"}}}");
+        conditions.Add("{\"status\":{\"eq\":\"A\"}}");
+
+        var filterJson = "{\"and\":[" + string.Join(",", conditions) + "]}";
+
+        var queryParams = new List<string>{
+            "pageSize=500",
+            $"filter={filterJson}"
+        };
+
+        serviceTask.SetQueryString(string.Join("&", queryParams));
+        return Task.FromResult(new ScriptResponse());
+    }
+
+    public Task<ScriptResponse> OutputHandler(ScriptContext context)
+    {
+        try
+        {
+            var advisorId = ReadParam(context, "advisorId");
+            var period = ReadParam(context, "period") ?? "week";
+            var startDate = ReadParam(context, "startDate");
+            var endDate = ReadParam(context, "endDate");
+
+            var response = context.Body;
+
+            if (response?.isSuccess == false)
+            {
+                return Task.FromResult(new ScriptResponse
+                {
+                    Key = "service-error",
+                    Data = new
+                    {
+                        error = "Failed to fetch reservations for stats",
+                        errorCode = "SERVICE_ERROR",
+                        errorMessage = response?.errorMessage?.ToString()
+                    },
+                    Tags = new[] { "advisor-stats", "error" }
+                });
+            }
+
+            var responseData = response?.data;
+            var items = responseData?.items;
+
+            int totalCount = 0;
+            int completedCount = 0;
+            int cancelledCount = 0;
+            int activeCount = 0;
+            int inMeetCount = 0;
+            double totalDurationMinutes = 0;
+
+            DateTime filterStart = DateTime.MinValue;
+            DateTime filterEnd = DateTime.MaxValue;
+            if (!string.IsNullOrEmpty(startDate)) DateTime.TryParse(startDate, out filterStart);
+            if (!string.IsNullOrEmpty(endDate)) DateTime.TryParse(endDate, out filterEnd);
+
+            if (items != null)
+            {
+                foreach (dynamic item in items)
+                {
+                    var attrs = item?.attributes;
+                    if (attrs == null) continue;
+
+                    string itemStartStr = attrs?.startDateTime?.ToString();
+                    if (string.IsNullOrEmpty(itemStartStr)) continue;
+
+                    DateTime itemStart;
+                    if (!DateTime.TryParse(itemStartStr, out itemStart)) continue;
+
+                    if (itemStart < filterStart || itemStart > filterEnd) continue;
+
+                    totalCount++;
+
+                    string state = item?.metadata?.currentState?.ToString() ?? "";
+                    if (state == "meet-completed" || state == "completed") completedCount++;
+                    else if (state == "user-cancelled" || state == "advisor-cancelled" || state == "timeout") cancelledCount++;
+                    else if (state == "active" || state == "can-start-meeting" || state == "accept-terms") activeCount++;
+                    else if (state == "in-meet") inMeetCount++;
+
+                    string itemEndStr = attrs?.endDateTime?.ToString();
+                    if (!string.IsNullOrEmpty(itemEndStr))
+                    {
+                        DateTime itemEnd;
+                        if (DateTime.TryParse(itemEndStr, out itemEnd))
+                            totalDurationMinutes += (itemEnd - itemStart).TotalMinutes;
+                    }
+                }
+            }
+
+            return Task.FromResult(new ScriptResponse
+            {
+                Key = "advisor-stats-success",
+                Data = new
+                {
+                    advisorId,
+                    period,
+                    startDate,
+                    endDate,
+                    totalReservations = totalCount,
+                    completed = completedCount,
+                    cancelled = cancelledCount,
+                    active = activeCount,
+                    inMeet = inMeetCount,
+                    averageDurationMinutes = totalCount > 0 ? Math.Round(totalDurationMinutes / totalCount, 1) : 0,
+                    totalDurationMinutes = Math.Round(totalDurationMinutes, 1)
+                },
+                Tags = new[] { "advisor-stats", "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[] { "advisor-stats", "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;
+    }
+}