@burgan-tech/morph-touch-runtime 0.0.2

package/touch/Workflows/src/CheckDuplicateRezervationMapping.csx

@@ -0,0 +1,150 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using BBT.Workflow.Scripting;
+using BBT.Workflow.Definitions;
+
+/// <summary>
+/// Mapping for check-duplicate-rezervation (DaprServiceTask - Type 3).
+/// Queries rezervation workflow instances to enforce two rules:
+/// 1. A user can have at most 2 reservations in confirmed states (active, update-control, change-advisor, can-start-meeting, accept-terms).
+/// 2. A user cannot have two reservations with overlapping time slots.
+///
+/// Flow:
+/// 1. InputHandler: Builds query to find all active reservations for the same user.
+/// 2. OutputHandler: Checks count (max 2) and time overlap; throws exception on violation.
+///    Exception fails the transition; instance stays in its current state.
+/// </summary>
+public class CheckDuplicateRezervationMapping : 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 || !HasProperty(data, "user") || data.user == null)
+            throw new InvalidOperationException("MAX_REZERVATION: User field is required for duplicate check");
+
+        var user = data.user.ToString();
+        var currentKey = context.Instance?.Key ?? "";
+
+        var userEscaped = user.Replace("\\", "\\\\").Replace("\"", "\\\"");
+        var keyEscaped = currentKey.Replace("\\", "\\\\").Replace("\"", "\\\"");
+
+        var queryParams = new List<string>
+        {
+            "pageSize=10",
+            "filter=" +
+                "{\"and\":[" +
+                    "{\"attributes\":{\"user\":{\"eq\":\"" + userEscaped + "\"}}}," +
+                    "{\"key\":{\"ne\":\"" + keyEscaped + "\"}}," +
+                    "{\"currentState\":{\"eq\":\"" + "active" + "\"}},"  +
+                "]}"
+        };
+
+        serviceTask.SetQueryString(string.Join("&", queryParams));
+
+        return Task.FromResult(new ScriptResponse());
+    }
+
+    public Task<ScriptResponse> OutputHandler(ScriptContext context)
+    {
+        var response = context.Body;
+
+        if (response?.isSuccess == false)
+        {
+            var errorMessage = response?.errorMessage?.ToString() ?? "Service call failed";
+            throw new Exception($"SERVICE_ERROR: {errorMessage}");
+        }
+
+        var responseData = response?.data;
+        var items = responseData?.items;
+
+        if (items == null || items.Count == 0)
+            return Task.FromResult(new ScriptResponse());
+
+        int count = items.Count;
+
+        if (count >= 2)
+        {
+            var user = context.Instance?.Data?.user?.ToString() ?? "unknown";
+            throw new Exception($"MAX_REZERVATION: User '{user}' already has {count} active reservations. Maximum allowed is 2.");
+        }
+
+        var instanceData = context.Instance?.Data;
+        var newStartStr = GetString(instanceData, "startDateTime");
+        var newEndStr = GetString(instanceData, "endDateTime");
+
+        if (!string.IsNullOrEmpty(newStartStr) && !string.IsNullOrEmpty(newEndStr))
+        {
+            DateTime newStart = default, newEnd = default;
+            if (DateTime.TryParse(newStartStr, out newStart) && DateTime.TryParse(newEndStr, out newEnd))
+            {
+                foreach (var item in items)
+                {
+                    if (item == null) continue;
+
+                    var existingStartStr = GetNestedString(item, "attributes", "startDateTime");
+                    var existingEndStr = GetNestedString(item, "attributes", "endDateTime");
+
+                    if (string.IsNullOrEmpty(existingStartStr) || string.IsNullOrEmpty(existingEndStr))
+                        continue;
+
+                    DateTime existingStart = default, existingEnd = default;
+                    if (!DateTime.TryParse(existingStartStr, out existingStart) ||
+                        !DateTime.TryParse(existingEndStr, out existingEnd))
+                        continue;
+
+                    if (existingStart < newEnd && existingEnd > newStart)
+                    {
+                        var existingKey = HasProperty(item, "key") ? item.key?.ToString() : "unknown";
+                        throw new Exception(
+                            $"TIME_OVERLAP: Requested time {newStartStr} - {newEndStr} overlaps with existing reservation '{existingKey}' ({existingStartStr} - {existingEndStr}).");
+                    }
+                }
+            }
+        }
+
+        return Task.FromResult(new ScriptResponse());
+    }
+
+    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;
+    }
+}

package/touch/Workflows/src/CheckExistingPermanentChatRoomMapping.csx

@@ -0,0 +1,169 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using BBT.Workflow.Scripting;
+using BBT.Workflow.Definitions;
+
+/// <summary>
+/// Mapping for check-existing-permanent-chat-room DaprServiceTask (Type 3).
+/// Calls get-chat-rooms flow function with user and roomType=permanent from InstanceData.
+/// Output: hasExistingPermanentRoom (bool), existingRoomAdvisorMatches (bool), existingChatRoomInstanceKey (string).
+/// - hasExistingPermanentRoom: true only if user has a permanent room with the same advisorType (e.g. PM request only counts PM rooms; IA request only counts IA rooms).
+/// - existingRoomAdvisorMatches: true if that room's advisorId also matches; false otherwise.
+/// - existingChatRoomInstanceKey: key of matching room, or first room with same advisorType when no match (for transfer).
+/// </summary>
+public class CheckExistingPermanentChatRoomMapping : 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 user = GetString(data, "user");
+        if (string.IsNullOrWhiteSpace(user))
+            throw new InvalidOperationException("user is required in instance data");
+
+        var queryParams = new List<string>
+        {
+            "user=" + Uri.EscapeDataString(user.Trim()),
+            "roomType=permanent",
+            "state=activated",
+            "pageSize=20"
+        };
+        serviceTask.SetQueryString(string.Join("&", queryParams));
+
+        return Task.FromResult(new ScriptResponse());
+    }
+
+    public Task<ScriptResponse> OutputHandler(ScriptContext context)
+    {
+        var response = context.Body;
+        var data = context.Instance?.Data;
+        var advisorId = GetString(data, "advisorId");
+        var advisorType = GetString(data, "advisorType");
+
+        bool hasExistingPermanentRoom = false;
+        bool existingRoomAdvisorMatches = false;
+        string existingChatRoomInstanceKey = null;
+        string firstRoomWithSameAdvisorTypeKey = null;
+
+        if (response?.isSuccess == true)
+        {
+            var responseData = response?.data ?? response?.Data ?? response;
+            var rooms = GetRoomsList(responseData);
+            if (rooms != null)
+            {
+                foreach (var room in rooms)
+                {
+                    var roomAdvisorType = GetString(room, "advisorType");
+                    if (!string.Equals(roomAdvisorType?.Trim(), advisorType?.Trim(), StringComparison.OrdinalIgnoreCase))
+                        continue;
+
+                    var roomKey = GetString(room, "instanceKey") ?? GetString(room, "key");
+                    if (string.IsNullOrWhiteSpace(roomKey)) continue;
+
+                    if (firstRoomWithSameAdvisorTypeKey == null)
+                        firstRoomWithSameAdvisorTypeKey = roomKey;
+
+                    hasExistingPermanentRoom = true;
+
+                    var roomAdvisorId = GetString(room, "advisorId");
+                    if (string.Equals(roomAdvisorId?.Trim(), advisorId?.Trim(), StringComparison.OrdinalIgnoreCase))
+                    {
+                        existingRoomAdvisorMatches = true;
+                        existingChatRoomInstanceKey = roomKey;
+                        break;
+                    }
+                }
+
+                if (hasExistingPermanentRoom && existingChatRoomInstanceKey == null)
+                    existingChatRoomInstanceKey = firstRoomWithSameAdvisorTypeKey;
+            }
+        }
+
+        return Task.FromResult(new ScriptResponse
+        {
+            Data = new
+            {
+                hasExistingPermanentRoom = hasExistingPermanentRoom,
+                existingRoomAdvisorMatches = existingRoomAdvisorMatches,
+                existingChatRoomInstanceKey = existingChatRoomInstanceKey
+            }
+        });
+    }
+
+    private System.Collections.IEnumerable GetRoomsList(dynamic responseData)
+    {
+        if (responseData == null) return null;
+        try
+        {
+            // Direct rooms
+            if (HasProperty(responseData, "rooms") && responseData.rooms != null)
+                return responseData.rooms;
+            if (HasProperty(responseData, "data") && responseData.data != null && HasProperty(responseData.data, "rooms"))
+                return responseData.data.rooms;
+            if (HasProperty(responseData, "Data") && responseData.Data != null && HasProperty(responseData.Data, "rooms"))
+                return responseData.Data.rooms;
+
+            // Wrapped: checkExistingData.items[].getChatRooms.rooms (runtime task result shape)
+            var checkExisting = GetValue(responseData, "checkExistingData") ?? GetValue(responseData, "data");
+            var root = checkExisting ?? responseData;
+            if (root != null && HasProperty(root, "items") && root.items != null)
+            {
+                var items = root.items as System.Collections.IEnumerable;
+                if (items != null)
+                {
+                    foreach (var item in items)
+                    {
+                        if (item == null) continue;
+                        var getChatRooms = GetValue(item, "getChatRooms");
+                        if (getChatRooms != null && HasProperty(getChatRooms, "rooms"))
+                        {
+                            var rooms = GetValue(getChatRooms, "rooms");
+                            if (rooms is System.Collections.IEnumerable en && en != null)
+                                return en;
+                        }
+                    }
+                }
+            }
+        }
+        catch { }
+        return null;
+    }
+
+    private object GetValue(dynamic obj, string name)
+    {
+        if (obj == null) return null;
+        try
+        {
+            if (HasProperty(obj, name))
+                return GetPropertyValue(obj, name);
+        }
+        catch { }
+        return 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()?.Trim();
+            }
+        }
+        catch { }
+        return null;
+    }
+}

package/touch/Workflows/src/CheckRandevuTimeMapping.csx

@@ -0,0 +1,67 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using BBT.Workflow.Scripting;
+using BBT.Workflow.Definitions;
+
+/// <summary>
+/// Mapping for check-randevu-time Script Task.
+/// Validates startDateTime is within 15 minutes. Throws MEET_NOT_STARTED if >15 min until start.
+/// </summary>
+public class CheckRandevuTimeMapping : ScriptBase, IMapping
+{
+    private const int MaxMinutesBeforeStart = 15;   
+
+
+
+    
+
+    public Task<ScriptResponse> InputHandler(WorkflowTask task, ScriptContext context)
+    {
+         var response = new ScriptResponse();
+         response.Data=new {};
+        return Task.FromResult(response
+        );
+    }
+
+    public Task<ScriptResponse> OutputHandler(ScriptContext context)
+    {
+        var data = context.Instance?.Data;
+        var startDateTimeStr = GetString(data, "startDateTime");
+        if (string.IsNullOrWhiteSpace(startDateTimeStr))
+            throw new InvalidOperationException("MEET_NOT_STARTED: startDateTime is required");
+
+        DateTime startDateTime;
+        if (!DateTime.TryParse(startDateTimeStr, out startDateTime))
+            throw new InvalidOperationException("MEET_NOT_STARTED: Invalid startDateTime format");
+
+        var now = DateTime.UtcNow.AddHours(3);
+        var diff = startDateTime - now;
+   
+        if (diff.TotalMinutes > MaxMinutesBeforeStart)
+            throw new InvalidOperationException("MEET_NOT_STARTED: Randevuya 15 dakikadan fazla var.");
+        LogError("Diff Minutes :"+diff.TotalMinutes+ "");
+        var result = new Dictionary<string, object>
+        {
+            { "timeOk", true },
+            { "minutesUntilStart", diff.TotalMinutes }
+        };
+
+        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;
+    }
+}

package/touch/Workflows/src/CheckRezervationStateActiveOrInMeetRule.csx

@@ -0,0 +1,14 @@
+using System.Threading.Tasks;
+using BBT.Workflow.Scripting;
+
+/// <summary>
+/// Condition for check-rezervation-state: state in (active, in-meet) -> check-time.
+/// </summary>
+public class CheckRezervationStateActiveOrInMeetRule : ScriptBase, IConditionMapping
+{
+    public Task<bool> Handler(ScriptContext context)
+    {
+        var state = context.Instance?.Data?.state?.ToString()?.Trim();
+        return Task.FromResult(state == "active" || state == "in-meet");
+    }
+}

package/touch/Workflows/src/CreateAbsenceEntryForRezervationMapping.csx

@@ -0,0 +1,111 @@
+using System;
+using System.Threading.Tasks;
+using BBT.Workflow.Scripting;
+using BBT.Workflow.Definitions;
+
+/// <summary>
+/// Mapping for start-absence-entry-for-rezervation StartTask (Type 11).
+/// Creates an absence-entry rezervation instance when rezervation reaches confirmation state.
+/// Key format: rezervation-{advisorId}-{startDateTime}-{endDateTime} (URL-safe: colons replaced with dashes).
+/// Start goes directly to complete state (no schedule needed).
+/// </summary>
+public class CreateAbsenceEntryForRezervationMapping : ScriptBase, IMapping
+{
+    public Task<ScriptResponse> InputHandler(WorkflowTask task, ScriptContext context)
+    {
+        var startTask = task as StartTask;
+        if (startTask == null)
+            throw new InvalidOperationException("Task must be a StartTask");
+
+        var data = context.Instance?.Data;
+        if (data == null || !HasProperty(data, "user") || !HasProperty(data, "advisor") ||
+            !HasProperty(data, "startDateTime") || !HasProperty(data, "endDateTime"))
+        {
+            return Task.FromResult(new ScriptResponse { Data = new { absenceEntryKey = (string)null } });
+        }
+
+        var user = data.user?.ToString()?.Trim();
+        var advisor = data.advisor?.ToString()?.Trim();
+        var startDateTime = data.startDateTime?.ToString()?.Trim();
+        var endDateTime = data.endDateTime?.ToString()?.Trim();
+        if (string.IsNullOrEmpty(user) || string.IsNullOrEmpty(advisor) ||
+            string.IsNullOrEmpty(startDateTime) || string.IsNullOrEmpty(endDateTime))
+        {
+            return Task.FromResult(new ScriptResponse { Data = new { absenceEntryKey = (string)null } });
+        }
+
+        var advisorId = NormalizeForKey(advisor);
+        var startNorm = NormalizeDateTimeForKey(startDateTime);
+        var endNorm = NormalizeDateTimeForKey(endDateTime);
+        var absenceEntryKey = $"rezervation-{advisorId}-{startNorm}-{endNorm}";
+
+        startTask.SetDomain("touch");
+        startTask.SetFlow("absence-entry");
+        startTask.SetKey(absenceEntryKey);
+        startTask.SetBody(new
+        {
+                absenceType = "rezervation",
+                advisor,
+                startDateTime,
+                endDateTime,
+                title = "Randevu"
+        });
+
+        return Task.FromResult(new ScriptResponse
+        {
+            Data = new { absenceEntryKey }
+        });
+    }
+
+    public Task<ScriptResponse> OutputHandler(ScriptContext context)
+    {
+        var response = new ScriptResponse();
+        if (context.Body?.isSuccess == true)
+        {
+            var data = context.Instance?.Data;
+            var user = data?.user?.ToString()?.Trim();
+            var advisor = data?.advisor?.ToString()?.Trim();
+            var startDateTime = data?.startDateTime?.ToString()?.Trim();
+            var endDateTime = data?.endDateTime?.ToString()?.Trim();
+            if (!string.IsNullOrEmpty(user) && !string.IsNullOrEmpty(advisor) &&
+                !string.IsNullOrEmpty(startDateTime) && !string.IsNullOrEmpty(endDateTime))
+            {
+                var advisorId = NormalizeForKey(advisor);
+                var startNorm = NormalizeDateTimeForKey(startDateTime);
+                var endNorm = NormalizeDateTimeForKey(endDateTime);
+                var absenceEntryKey = $"rezervation-{advisorId}-{startNorm}-{endNorm}";
+                response.Data = new
+                {
+                    absenceEntryKey,
+                    absenceEntryResponse = data,
+                    absenceEntryCreated = true
+                };
+            }
+            else
+            {
+                response.Data = new { absenceEntryCreated = true };
+            }
+        }
+        else
+        {
+            response.Data = new
+            {
+                absenceEntryCreated = false,
+                error = context.Body?.errorMessage ?? "Failed to start absence-entry"
+            };
+        }
+        return Task.FromResult(response);
+    }
+
+    private  string NormalizeForKey(string value)
+    {
+        if (string.IsNullOrEmpty(value)) return value;
+        return value.Replace(":", "-").Replace(" ", "-");
+    }
+
+    private  string NormalizeDateTimeForKey(string dateTimeStr)
+    {
+        if (string.IsNullOrEmpty(dateTimeStr)) return dateTimeStr;
+        return dateTimeStr.Replace(":", "-").Replace(" ", "-");
+    }
+}

package/touch/Workflows/src/CreateAbsenceForRandevuUpdateMapping.csx

@@ -0,0 +1,108 @@
+using System;
+using System.Threading.Tasks;
+using BBT.Workflow.Scripting;
+using BBT.Workflow.Definitions;
+
+/// <summary>
+/// Mapping for start-absence-entry-for-rezervation in randevu-update flow.
+/// Creates absence-entry for the new advisor + start/end (from merged instance data).
+/// </summary>
+public class CreateAbsenceForRandevuUpdateMapping : ScriptBase, IMapping
+{
+    public Task<ScriptResponse> InputHandler(WorkflowTask task, ScriptContext context)
+    {
+        var startTask = task as StartTask;
+        if (startTask == null)
+            throw new InvalidOperationException("Task must be a StartTask");
+
+        var data = context.Instance?.Data;
+        if (data == null)
+            return Task.FromResult(new ScriptResponse { Data = new { absenceEntryKey = (string)null } });
+
+        var advisor = GetString(data, "advisor");
+        var startDateTime = GetString(data, "startDateTime");
+        var endDateTime = GetString(data, "endDateTime");
+
+        if (string.IsNullOrEmpty(advisor) || string.IsNullOrEmpty(startDateTime) || string.IsNullOrEmpty(endDateTime))
+            return Task.FromResult(new ScriptResponse { Data = new { absenceEntryKey = (string)null } });
+
+        var advisorId = NormalizeForKey(advisor);
+        var startNorm = NormalizeDateTimeForKey(startDateTime);
+        var endNorm = NormalizeDateTimeForKey(endDateTime);
+        var absenceEntryKey = $"rezervation-{advisorId}-{startNorm}-{endNorm}";
+
+        startTask.SetDomain("touch");
+        startTask.SetFlow("absence-entry");
+        startTask.SetKey(absenceEntryKey);
+        startTask.SetBody(new
+        {
+            absenceType = "rezervation",
+            advisor = advisor.Trim(),
+            startDateTime,
+            endDateTime,
+            title = "Randevu"
+        });
+
+        return Task.FromResult(new ScriptResponse { Data = new { absenceEntryKey } });
+    }
+
+    public Task<ScriptResponse> OutputHandler(ScriptContext context)
+    {
+        var response = new ScriptResponse();
+        if (context.Body?.isSuccess == true)
+        {
+            var data = context.Instance?.Data;
+            var advisor = GetString(data, "advisor");
+            var startDateTime = GetString(data, "startDateTime");
+            var endDateTime = GetString(data, "endDateTime");
+            if (!string.IsNullOrEmpty(advisor) && !string.IsNullOrEmpty(startDateTime) && !string.IsNullOrEmpty(endDateTime))
+            {
+                var advisorId = NormalizeForKey(advisor);
+                var startNorm = NormalizeDateTimeForKey(startDateTime);
+                var endNorm = NormalizeDateTimeForKey(endDateTime);
+                var absenceEntryKey = $"rezervation-{advisorId}-{startNorm}-{endNorm}";
+                response.Data = new { absenceEntryKey, absenceEntryCreated = true };
+            }
+            else
+            {
+                response.Data = new { absenceEntryCreated = true };
+            }
+        }
+        else
+        {
+            response.Data = new
+            {
+                absenceEntryCreated = false,
+                error = context.Body?.errorMessage ?? "Failed to start absence-entry"
+            };
+        }
+        return Task.FromResult(response);
+    }
+
+    private string NormalizeForKey(string value)
+    {
+        if (string.IsNullOrEmpty(value)) return value;
+        return value.Replace(":", "-").Replace(" ", "-");
+    }
+
+    private string NormalizeDateTimeForKey(string dateTimeStr)
+    {
+        if (string.IsNullOrEmpty(dateTimeStr)) return dateTimeStr;
+        return dateTimeStr.Replace(":", "-").Replace(" ", "-");
+    }
+
+    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;
+    }
+}