diff --git a/Bot/InterviewSchedulingBotEnhanced.cs b/Bot/InterviewSchedulingBotEnhanced.cs index d0342be..deae33b 100644 --- a/Bot/InterviewSchedulingBotEnhanced.cs +++ b/Bot/InterviewSchedulingBotEnhanced.cs @@ -15,7 +15,11 @@ using InterviewSchedulingBot.Services; using InterviewSchedulingBot.Models; using InterviewBot.Domain.Entities; +using InterviewBot.Models; +using InterviewBot.Services; using System.Globalization; +using System.Text.RegularExpressions; +using Microsoft.Extensions.Logging.Abstractions; namespace InterviewBot.Bot { @@ -33,12 +37,17 @@ public class InterviewSchedulingBotEnhanced : TeamsActivityHandler private readonly ILogger _logger; private readonly IAIResponseService _aiResponseService; private readonly InterviewBot.Domain.Interfaces.ISchedulingService _schedulingService; - private readonly IOpenWebUIClient _openWebUIClient; + private readonly IOpenWebUIIntegration _openWebUIIntegration; private readonly ICleanOpenWebUIClient _cleanOpenWebUIClient; private readonly IConversationStore _conversationStore; private readonly ConversationStateManager _stateManager; private readonly SlotQueryParser _slotQueryParser; private readonly ConversationalResponseGenerator _conversationalResponseGenerator; + private readonly DeterministicSlotRecommendationService _deterministicSlotService; + private readonly TimeSlotResponseFormatter _timeSlotFormatter; + private readonly NaturalLanguageDateProcessor _naturalLanguageDateProcessor; + private readonly ConversationalAIResponseFormatter _conversationalAIResponseFormatter; + private readonly IAIOrchestrator _aiOrchestrator; public InterviewSchedulingBotEnhanced( IAuthenticationService authService, @@ -53,12 +62,17 @@ public InterviewSchedulingBotEnhanced( ILoggerFactory loggerFactory, IAIResponseService aiResponseService, InterviewBot.Domain.Interfaces.ISchedulingService schedulingService, - IOpenWebUIClient openWebUIClient, + IOpenWebUIIntegration openWebUIIntegration, ICleanOpenWebUIClient cleanOpenWebUIClient, IConversationStore conversationStore, ConversationStateManager stateManager, SlotQueryParser slotQueryParser, - ConversationalResponseGenerator conversationalResponseGenerator) + ConversationalResponseGenerator conversationalResponseGenerator, + DeterministicSlotRecommendationService deterministicSlotService, + TimeSlotResponseFormatter timeSlotFormatter, + NaturalLanguageDateProcessor naturalLanguageDateProcessor, + ConversationalAIResponseFormatter conversationalAIResponseFormatter, + IAIOrchestrator aiOrchestrator) { _authService = authService; _schedulingBusinessService = schedulingBusinessService; @@ -71,12 +85,17 @@ public InterviewSchedulingBotEnhanced( _logger = logger; _aiResponseService = aiResponseService; _schedulingService = schedulingService; - _openWebUIClient = openWebUIClient; + _openWebUIIntegration = openWebUIIntegration; _cleanOpenWebUIClient = cleanOpenWebUIClient; _conversationStore = conversationStore; _stateManager = stateManager; _slotQueryParser = slotQueryParser; _conversationalResponseGenerator = conversationalResponseGenerator; + _deterministicSlotService = deterministicSlotService; + _timeSlotFormatter = timeSlotFormatter; + _naturalLanguageDateProcessor = naturalLanguageDateProcessor; + _conversationalAIResponseFormatter = conversationalAIResponseFormatter; + _aiOrchestrator = aiOrchestrator; // Setup dialogs with specific loggers _dialogs = new DialogSet(_accessors.DialogStateAccessor); @@ -163,6 +182,25 @@ protected override async Task OnMessageActivityAsync( // Fallback to original parameter extraction if SlotQueryParser fails var parameters = await _cleanOpenWebUIClient.ExtractParametersAsync(userMessage); + // Check if this is a slot request with emails - use pure AI orchestrator + if ((userMessage.Contains("slot") || userMessage.Contains("schedule") || userMessage.Contains("time") || userMessage.Contains("meeting")) + && ExtractEmailsFromMessage(userMessage).Any()) + { + var aiResponse = await _aiOrchestrator.ProcessSchedulingRequestAsync(userMessage, DateTime.Now); + + // Add to conversation history + await _stateManager.AddToHistoryAsync( + conversationId, + new MessageRecord { Text = userMessage, IsFromBot = false, Timestamp = DateTime.UtcNow }); + + await _stateManager.AddToHistoryAsync( + conversationId, + new MessageRecord { Text = aiResponse, IsFromBot = true, Timestamp = DateTime.UtcNow }); + + await turnContext.SendActivityAsync(MessageFactory.Text(aiResponse), cancellationToken); + return; + } + // If we have SlotQueryCriteria, use it to enhance parameters if (currentCriteria != null) { @@ -217,24 +255,15 @@ private async Task GenerateWelcomeResponseAsync(MeetingParameters parame { try { - // Use OpenWebUI to generate a dynamic welcome message - var prompt = @"Generate a professional welcome message for an AI-powered interview scheduling assistant. - Include: greeting, what you can help with (finding time slots, scheduling meetings, calendar management), - mention natural language support, and ask how you can help today. Keep it warm but professional."; - - var context = new { type = "welcome", capabilities = new[] { "time_slots", "scheduling", "calendar_management" } }; - - var response = await _openWebUIClient.GenerateResponseAsync(prompt, context); - return response; + // Use the new pure AI integration for welcome messages + return await _openWebUIIntegration.GenerateConversationalResponseAsync("welcome"); } catch (Exception ex) { _logger.LogError(ex, "Failed to generate welcome response using OpenWebUI API"); - // Send detailed error message to user about API connectivity - return $"āš ļø **System Error**: Unable to connect to AI service. Please check that OpenWebUI is properly configured and accessible.\n\n" + - $"**Error Details**: {ex.Message}\n\n" + - "Please contact your system administrator to resolve this issue."; + // Fallback welcome message + return "Hello! šŸ‘‹ I'm your AI-powered Interview Scheduling assistant. I can help you find available time slots and check calendar availability using natural language. What would you like me to help you with today?"; } } @@ -254,20 +283,15 @@ private async Task GenerateResponseAsync(MeetingParameters parameters, s return await GenerateSlotsResponseAsync(slots, parameters, originalMessage); } - // Otherwise generate a general AI response - var prompt = $"The user said: '{originalMessage}'. Generate a helpful response for an interview scheduling assistant."; - var context = new { userMessage = originalMessage, extractedParameters = parameters }; - - var response = await _openWebUIClient.GenerateResponseAsync(prompt, context); - return response; + // For general messages, use the pure AI integration + return await _openWebUIIntegration.ProcessGeneralMessageAsync(originalMessage); } catch (Exception ex) { - _logger.LogError(ex, "Failed to generate response using OpenWebUI API"); + _logger.LogError(ex, "Error generating response: {Error}", ex.Message); - return $"āš ļø **System Error**: Unable to connect to AI service to process your request.\n\n" + - $"**Error Details**: {ex.Message}\n\n" + - "Please contact your system administrator to resolve this issue."; + // Provide helpful fallback response instead of technical error + return "I'm here to help with interview scheduling! You can ask me to find time slots, check availability, or schedule meetings using natural language. For example, try 'Find slots tomorrow afternoon with john@company.com' or 'Check when we're all available next week'. How can I assist you today?"; } } @@ -852,5 +876,153 @@ private string GetRequestedTimeRangeInfo(SlotQueryCriteria criteria) _ => null }; } + + // New methods for handling slot requests with deterministic behavior + private async Task HandleSlotRequestAsync(ITurnContext turnContext, string message, CancellationToken cancellationToken) + { + try + { + // Extract emails + var emails = ExtractEmailsFromMessage(message); + if (!emails.Any()) + { + await turnContext.SendActivityAsync("I couldn't find any email addresses in your request. Please include participant emails."); + return; + } + + // Extract duration + int duration = ExtractDurationFromMessage(message); + + // Use robust AI-driven date interpretation + var aiDateInterpreter = new AIDateInterpreter(_openWebUIIntegration, + _logger as ILogger ?? new NullLogger()); + + var dateInterpretation = await aiDateInterpreter.InterpretDateReferenceAsync(message, DateTime.Now); + + _logger.LogInformation("Date interpretation result: {StartDate} to {EndDate}, WasAdjusted: {WasAdjusted}, Explanation: {Explanation}", + dateInterpretation.StartDate, dateInterpretation.EndDate, dateInterpretation.WasAdjusted, dateInterpretation.Explanation); + + // Generate initial limited set of best time slots + var enhancedSlots = _deterministicSlotService.GenerateConsistentTimeSlots( + dateInterpretation.StartDate, + dateInterpretation.EndDate, + duration, + emails, + maxInitialResults: 5); // Show fewer initial options + + // Use AI-driven conversational response formatting + string response = await _conversationalAIResponseFormatter.FormatTimeSlotResponseAsync( + enhancedSlots, + dateInterpretation.StartDate, + dateInterpretation.EndDate, + duration, + message, + dateInterpretation.WasAdjusted, + dateInterpretation.Explanation); + + await turnContext.SendActivityAsync(MessageFactory.Text(response), cancellationToken); + } + catch (Exception ex) + { + _logger.LogError(ex, "Error in HandleSlotRequestAsync for message: {Message}", message); + await turnContext.SendActivityAsync("I encountered an error processing your scheduling request. Please try again with a different format."); + } + } + + /// + /// Check if the original request was for a weekend day that got adjusted to a business day using AI + /// + private async Task CheckIfWeekendWasAdjustedAsync(string originalRequest, (DateTime startDate, DateTime endDate) dateRange, DateTime currentDate) + { + try + { + // Use AI to determine if weekend adjustment occurred + var context = $"Original request: '{originalRequest}' on {currentDate:dddd}. Result dates: {dateRange.startDate:dddd} to {dateRange.endDate:dddd}"; + var response = await _openWebUIIntegration.GenerateConversationalResponseAsync("weekend_adjustment_check", context); + + // Simple check: if response contains "weekend" or "adjusted", assume adjustment occurred + return response.ToLowerInvariant().Contains("weekend") || response.ToLowerInvariant().Contains("adjusted"); + } + catch + { + // Fallback to simple logic + var requestLower = originalRequest.ToLowerInvariant(); + if (requestLower.Contains("tomorrow")) + { + var actualTomorrow = currentDate.AddDays(1).Date; + var isWeekend = actualTomorrow.DayOfWeek == DayOfWeek.Saturday || actualTomorrow.DayOfWeek == DayOfWeek.Sunday; + var resultIsNotTomorrow = dateRange.startDate.Date != actualTomorrow; + + return isWeekend && resultIsNotTomorrow; + } + + return false; + } + } + + private List ExtractEmailsFromMessage(string message) + { + // Use regex to extract emails + var emails = new List(); + var regex = new Regex(@"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}"); + var matches = regex.Matches(message); + foreach (Match match in matches) + { + emails.Add(match.Value); + } + return emails; + } + + private int ExtractDurationFromMessage(string message) + { + // Use regex to extract duration + var regex = new Regex(@"(\d+)\s*(?:min|mins|minutes)"); + var match = regex.Match(message); + if (match.Success && int.TryParse(match.Groups[1].Value, out int duration)) + { + return duration; + } + return 60; // Default to 60 minutes + } + + private (DateTime start, DateTime end) ExtractDateRangeFromMessage(string message) + { + DateTime now = DateTime.Now; + DateTime tomorrow = DateFormattingService.GetNextBusinessDay(now); + + // Default to tomorrow + DateTime start = new DateTime(tomorrow.Year, tomorrow.Month, tomorrow.Day, 9, 0, 0); + DateTime end = new DateTime(tomorrow.Year, tomorrow.Month, tomorrow.Day, 17, 0, 0); + + // Handle specific time ranges + if (message.Contains("tomorrow")) + { + // Already set to tomorrow + } + else if (message.Contains("next week")) + { + // Find next Monday + DateTime nextMonday = now.Date; + while (nextMonday.DayOfWeek != DayOfWeek.Monday || nextMonday.Date <= now.Date) + nextMonday = nextMonday.AddDays(1); + + start = new DateTime(nextMonday.Year, nextMonday.Month, nextMonday.Day, 9, 0, 0); + end = new DateTime(nextMonday.AddDays(4).Year, nextMonday.AddDays(4).Month, nextMonday.AddDays(4).Day, 17, 0, 0); + } + + // Handle time of day + if (message.Contains("morning")) + { + start = new DateTime(start.Year, start.Month, start.Day, 9, 0, 0); + end = new DateTime(end.Year, end.Month, end.Day, 12, 0, 0); + } + else if (message.Contains("afternoon")) + { + start = new DateTime(start.Year, start.Month, start.Day, 13, 0, 0); + end = new DateTime(end.Year, end.Month, end.Day, 17, 0, 0); + } + + return (start, end); + } } } \ No newline at end of file diff --git a/InterviewBot.db-shm b/InterviewBot.db-shm new file mode 100644 index 0000000..fe9ac28 Binary files /dev/null and b/InterviewBot.db-shm differ diff --git a/InterviewBot.db-wal b/InterviewBot.db-wal new file mode 100644 index 0000000..e69de29 diff --git a/Models/EnhancedTimeSlot.cs b/Models/EnhancedTimeSlot.cs new file mode 100644 index 0000000..58f89a0 --- /dev/null +++ b/Models/EnhancedTimeSlot.cs @@ -0,0 +1,38 @@ +using System; +using System.Collections.Generic; + +namespace InterviewBot.Models +{ + public class EnhancedTimeSlot + { + public DateTime StartTime { get; set; } + public DateTime EndTime { get; set; } + public List AvailableParticipants { get; set; } = new List(); + public List UnavailableParticipants { get; set; } = new List(); + public double Score { get; set; } + public string Reason { get; set; } = ""; + public bool IsRecommended { get; set; } + + public string GetFormattedTimeRange() => + $"{StartTime:HH:mm} - {EndTime:HH:mm}"; + + public string GetFormattedDateWithDay() => + $"{StartTime:dddd} [{StartTime:dd.MM.yyyy}]"; + + // Add method to format participant availability with specific unavailable participants + public string GetParticipantAvailabilityDescription() + { + if (AvailableParticipants.Count == 0) + return "(No participants available)"; + + if (UnavailableParticipants.Count == 0) + return "(All participants available)"; + + // Format specific unavailable participants + string unavailableNames = string.Join(", ", UnavailableParticipants + .Select(email => email.Split('@')[0])); // Extract name from email + + return $"({AvailableParticipants.Count}/{AvailableParticipants.Count + UnavailableParticipants.Count} participants - {unavailableNames} unavailable)"; + } + } +} \ No newline at end of file diff --git a/Program.cs b/Program.cs index 7b8fba4..120afcb 100644 --- a/Program.cs +++ b/Program.cs @@ -72,6 +72,7 @@ // Register Natural Language Processing Services builder.Services.AddHttpClient(); builder.Services.AddHttpClient(); +builder.Services.AddHttpClient(); builder.Services.AddScoped(); builder.Services.AddScoped(); builder.Services.AddScoped(); @@ -91,6 +92,18 @@ builder.Services.AddHttpClient(); builder.Services.AddScoped(); +// Register new deterministic slot generation services +builder.Services.AddSingleton(); +builder.Services.AddSingleton(); +builder.Services.AddSingleton(); + +// Register new AI-driven services for pure natural language processing +builder.Services.AddScoped(); +builder.Services.AddScoped(); + +// Register pure AI orchestrator for slot scheduling +builder.Services.AddScoped(); + // === EXISTING SERVICES === // Add services to the container. diff --git a/Services/AIDateInterpreter.cs b/Services/AIDateInterpreter.cs new file mode 100644 index 0000000..c52dd01 --- /dev/null +++ b/Services/AIDateInterpreter.cs @@ -0,0 +1,283 @@ +using System; +using System.Text.Json; +using System.Text.Json.Serialization; +using System.Threading.Tasks; +using Microsoft.Extensions.Logging; +using InterviewSchedulingBot.Services.Integration; + +namespace InterviewBot.Services +{ + /// + /// Pure AI-driven date interpreter that handles natural language date references + /// with intelligent business day adjustments and fallback logic + /// + public class AIDateInterpreter + { + private readonly IOpenWebUIIntegration _aiService; + private readonly ILogger _logger; + + public AIDateInterpreter(IOpenWebUIIntegration aiService, ILogger logger) + { + _aiService = aiService; + _logger = logger; + } + + public async Task InterpretDateReferenceAsync( + string userQuery, + DateTime currentDate) + { + try + { + _logger.LogInformation("Interpreting date reference: '{Query}' with current date: {CurrentDate:yyyy-MM-dd dddd}", + userQuery, currentDate); + + // Create a specialized system prompt for date extraction + string systemPrompt = $@"You are a business calendar date interpreter. Parse the user's natural language date request into specific dates. + +CURRENT CONTEXT: +- Today: {currentDate:yyyy-MM-dd} ({currentDate:dddd}) +- Business hours: Monday-Friday, 9 AM to 5 PM + +BUSINESS RULES: +1. ""tomorrow"" = next business day if tomorrow is weekend, otherwise literal tomorrow +2. ""next week"" = Monday through Friday of the upcoming week +3. ""first X days of next week"" = exactly X consecutive business days starting from next Monday +4. Always prefer business days unless explicitly asked for weekends + +USER REQUEST: ""{userQuery}"" + +Respond with ONLY valid JSON: +{{ + ""startDate"": ""yyyy-MM-dd"", + ""endDate"": ""yyyy-MM-dd"", + ""explanation"": ""brief explanation if weekend was adjusted"", + ""wasAdjusted"": true/false +}} + +Examples: +- ""tomorrow"" when today is Friday ā†’ {{""startDate"": ""2025-08-04"", ""endDate"": ""2025-08-04"", ""explanation"": """", ""wasAdjusted"": false}} +- ""tomorrow"" when today is Friday and tomorrow is Saturday ā†’ {{""startDate"": ""2025-08-04"", ""endDate"": ""2025-08-04"", ""explanation"": ""Adjusted to Monday as tomorrow is Saturday"", ""wasAdjusted"": true}} +- ""first 2 days of next week"" ā†’ {{""startDate"": ""2025-08-04"", ""endDate"": ""2025-08-05"", ""explanation"": """", ""wasAdjusted"": false}}"; + + // Try AI interpretation first + var aiResult = await TryAIInterpretationAsync(systemPrompt, userQuery); + if (aiResult != null) + { + _logger.LogInformation("AI interpretation successful: {StartDate} to {EndDate}", + aiResult.StartDate, aiResult.EndDate); + return aiResult; + } + + // Fallback to intelligent semantic parsing + var fallbackResult = CreateIntelligentFallback(userQuery, currentDate); + _logger.LogInformation("Using intelligent fallback: {StartDate} to {EndDate}", + fallbackResult.StartDate, fallbackResult.EndDate); + return fallbackResult; + } + catch (Exception ex) + { + _logger.LogError(ex, "Error interpreting date reference"); + return CreateIntelligentFallback(userQuery, currentDate); + } + } + + private async Task TryAIInterpretationAsync(string systemPrompt, string userQuery) + { + try + { + // Use the OpenWebUI integration to get AI interpretation + var response = await _aiService.GenerateConversationalResponseAsync(systemPrompt, new { query = userQuery }); + + if (string.IsNullOrEmpty(response)) + return null; + + // Try to extract JSON from the response + var jsonStart = response.IndexOf('{'); + var jsonEnd = response.LastIndexOf('}'); + + if (jsonStart >= 0 && jsonEnd > jsonStart) + { + var jsonStr = response.Substring(jsonStart, jsonEnd - jsonStart + 1); + var result = JsonSerializer.Deserialize(jsonStr); + + if (DateTime.TryParse(result?.StartDate, out var startDate) && + DateTime.TryParse(result?.EndDate, out var endDate)) + { + return new DateInterpretationResult + { + StartDate = startDate, + EndDate = endDate, + Explanation = result.Explanation ?? "", + WasAdjusted = result.WasAdjusted + }; + } + } + } + catch (Exception ex) + { + _logger.LogWarning(ex, "AI interpretation failed, will use fallback"); + } + + return null; + } + + private DateInterpretationResult CreateIntelligentFallback(string userQuery, DateTime currentDate) + { + var query = userQuery.ToLowerInvariant(); + + // Handle "tomorrow" with business day intelligence + if (query.Contains("tomorrow")) + { + var tomorrow = currentDate.AddDays(1); + bool wasAdjusted = false; + string explanation = ""; + + // If tomorrow is weekend, adjust to next Monday + if (IsWeekend(tomorrow)) + { + tomorrow = GetNextMonday(currentDate); + wasAdjusted = true; + explanation = $"Adjusted to Monday as tomorrow is {currentDate.AddDays(1):dddd}"; + } + + return new DateInterpretationResult + { + StartDate = tomorrow, + EndDate = tomorrow, + Explanation = explanation, + WasAdjusted = wasAdjusted + }; + } + + // Handle "first X days of next week" + if (query.Contains("first") && query.Contains("next week")) + { + var dayCount = ExtractDayCount(query); + var nextMonday = GetNextMonday(currentDate); + var endDate = nextMonday.AddDays(Math.Max(0, dayCount - 1)); + + return new DateInterpretationResult + { + StartDate = nextMonday, + EndDate = endDate, + Explanation = "", + WasAdjusted = false + }; + } + + // Handle "next week" + if (query.Contains("next week")) + { + var nextMonday = GetNextMonday(currentDate); + var nextFriday = nextMonday.AddDays(4); + + return new DateInterpretationResult + { + StartDate = nextMonday, + EndDate = nextFriday, + Explanation = "", + WasAdjusted = false + }; + } + + // Handle specific days (Monday, Tuesday, etc.) + var specificDay = ExtractSpecificDay(query); + if (specificDay.HasValue) + { + var targetDate = GetNextWeekday(currentDate, specificDay.Value); + return new DateInterpretationResult + { + StartDate = targetDate, + EndDate = targetDate, + Explanation = "", + WasAdjusted = false + }; + } + + // Default: next business day + var nextBusinessDay = GetNextBusinessDay(currentDate); + bool defaultWasAdjusted = IsWeekend(currentDate.AddDays(1)); + + return new DateInterpretationResult + { + StartDate = nextBusinessDay, + EndDate = nextBusinessDay, + Explanation = defaultWasAdjusted ? "Defaulted to next business day" : "", + WasAdjusted = defaultWasAdjusted + }; + } + + // Helper methods for date calculations + private bool IsWeekend(DateTime date) => + date.DayOfWeek == DayOfWeek.Saturday || date.DayOfWeek == DayOfWeek.Sunday; + + private DateTime GetNextBusinessDay(DateTime currentDate) + { + var nextDay = currentDate.AddDays(1); + while (IsWeekend(nextDay)) + { + nextDay = nextDay.AddDays(1); + } + return nextDay; + } + + private DateTime GetNextMonday(DateTime currentDate) + { + var daysUntilMonday = ((int)DayOfWeek.Monday - (int)currentDate.DayOfWeek + 7) % 7; + if (daysUntilMonday == 0) daysUntilMonday = 7; // If today is Monday, get next Monday + return currentDate.AddDays(daysUntilMonday); + } + + private DateTime GetNextWeekday(DateTime currentDate, DayOfWeek targetDay) + { + var daysUntilTarget = ((int)targetDay - (int)currentDate.DayOfWeek + 7) % 7; + if (daysUntilTarget == 0) daysUntilTarget = 7; // If today is the target day, get next week + return currentDate.AddDays(daysUntilTarget); + } + + private int ExtractDayCount(string query) + { + if (query.Contains("2") || query.Contains("two")) return 2; + if (query.Contains("3") || query.Contains("three")) return 3; + if (query.Contains("4") || query.Contains("four")) return 4; + if (query.Contains("5") || query.Contains("five")) return 5; + return 1; // Default + } + + private DayOfWeek? ExtractSpecificDay(string query) + { + if (query.Contains("monday")) return DayOfWeek.Monday; + if (query.Contains("tuesday")) return DayOfWeek.Tuesday; + if (query.Contains("wednesday")) return DayOfWeek.Wednesday; + if (query.Contains("thursday")) return DayOfWeek.Thursday; + if (query.Contains("friday")) return DayOfWeek.Friday; + if (query.Contains("saturday")) return DayOfWeek.Saturday; + if (query.Contains("sunday")) return DayOfWeek.Sunday; + return null; + } + } + + public class DateInterpretationResult + { + public DateTime StartDate { get; set; } + public DateTime EndDate { get; set; } + public string Explanation { get; set; } = ""; + public bool WasAdjusted { get; set; } + } + + // Internal class for JSON deserialization + internal class DateInterpretationJson + { + [JsonPropertyName("startDate")] + public string? StartDate { get; set; } + + [JsonPropertyName("endDate")] + public string? EndDate { get; set; } + + [JsonPropertyName("explanation")] + public string? Explanation { get; set; } + + [JsonPropertyName("wasAdjusted")] + public bool WasAdjusted { get; set; } + } +} \ No newline at end of file diff --git a/Services/AIOrchestrator.cs b/Services/AIOrchestrator.cs new file mode 100644 index 0000000..c9aeeb1 --- /dev/null +++ b/Services/AIOrchestrator.cs @@ -0,0 +1,332 @@ +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Threading.Tasks; +using Microsoft.Extensions.Logging; +using Microsoft.Extensions.Configuration; +using System.Linq; +using System.Text.RegularExpressions; +using InterviewBot.Models; +using InterviewSchedulingBot.Services.Integration; + +namespace InterviewBot.Services +{ + public interface IAIOrchestrator + { + Task ProcessSchedulingRequestAsync(string userMessage, DateTime currentTime); + } + + public class AIOrchestrator : IAIOrchestrator + { + private readonly IOpenWebUIIntegration _aiClient; + private readonly ILogger _logger; + + public AIOrchestrator( + IOpenWebUIIntegration aiClient, + ILogger logger) + { + _aiClient = aiClient; + _logger = logger; + } + + public async Task ProcessSchedulingRequestAsync(string userMessage, DateTime currentTime) + { + try + { + _logger.LogInformation("Processing scheduling request: {Message}", userMessage); + + // Extract emails and duration for context + var emails = ExtractEmails(userMessage); + var duration = ExtractDuration(userMessage) ?? 60; + + if (!emails.Any()) + { + return "I'd be happy to help you find available time slots! To get started, please include participant email addresses in your request. For example: 'Find slots tomorrow with john@company.com' or 'Check availability for 90 minutes next week with jane@company.com'."; + } + + // Use pure AI to interpret the scheduling request and generate slots + var aiResponse = await GenerateAISchedulingResponseAsync(userMessage, emails, duration, currentTime); + + return aiResponse; + } + catch (Exception ex) + { + _logger.LogError(ex, "Error in AIOrchestrator processing: {Message}", userMessage); + return "I encountered an error processing your scheduling request. Please try again with a different format."; + } + } + + private async Task GenerateAISchedulingResponseAsync(string userMessage, List emails, int duration, DateTime currentTime) + { + try + { + var systemPrompt = $@"You are an AI-powered scheduling assistant. The current date/time is {currentTime:yyyy-MM-dd dddd HH:mm}. + +TASK: Generate available time slots based on the user's request and provide a comprehensive response. + +USER REQUEST: ""{userMessage}"" +PARTICIPANTS: {string.Join(", ", emails)} +DURATION: {duration} minutes + +BUSINESS RULES: +1. Business hours: Monday-Friday, 9:00 AM to 5:00 PM +2. Slot times always align to quarter hours (00, 15, 30, 45 minutes) +3. If user asks for weekend days, automatically adjust to next business days with explanation +4. Show 3-5 best slots per day with realistic availability +5. Include specific unavailable participant information when relevant + +RESPONSE FORMAT: +- Start with conversational acknowledgment of the request +- If weekend adjustment occurred, explain it clearly +- Show time slots in this format: + ""[Day] [DD.MM.YYYY] + HH:MM - HH:MM (All participants available) ā­ RECOMMENDED + HH:MM - HH:MM (2/2 participants available)"" +- End with helpful closing + +EXAMPLE OUTPUT: +""Since you asked for tomorrow but it's Saturday, I've found the following 60-minute time slots for the next business days: + +Monday [04.08.2025] +09:00 - 10:00 (All participants available) ā­ RECOMMENDED +10:15 - 11:15 (All participants available) +14:30 - 15:30 (2/2 participants available) + +Tuesday [05.08.2025] +09:30 - 10:30 (All participants available) ā­ RECOMMENDED +11:00 - 12:00 (2/2 participants available) + +Please let me know which time slot works best for you!"" + +Generate a complete response now:"; + + var response = await _aiClient.GenerateConversationalResponseAsync(systemPrompt); + + // Always use intelligent fallback for scheduling requests since OpenWebUI may be mocked + if (string.IsNullOrEmpty(response) || response.Length < 100) + { + _logger.LogInformation("OpenWebUI response was empty or too short, using intelligent fallback"); + return CreateIntelligentFallbackResponse(userMessage, emails, duration, currentTime); + } + + return response; + } + catch (Exception ex) + { + _logger.LogError(ex, "AI scheduling response generation failed"); + return CreateIntelligentFallbackResponse(userMessage, emails, duration, currentTime); + } + } + + private string CreateIntelligentFallbackResponse(string userMessage, List emails, int duration, DateTime currentTime) + { + var lowerMessage = userMessage.ToLowerInvariant(); + + // Determine target date range + var (startDate, endDate, explanation) = DetermineTargetDateRange(lowerMessage, currentTime); + + // Generate realistic time slots + var slots = GenerateRealisticTimeSlots(startDate, endDate, duration, emails.Count); + + // Format response + var response = new List(); + + if (!string.IsNullOrEmpty(explanation)) + { + response.Add(explanation); + response.Add(""); // Add blank line after explanation + } + else + { + // Add conversational opening + response.Add($"I've found the following {duration}-minute time slots:"); + response.Add(""); // Add blank line + } + + // Group slots by day + var slotsByDay = slots.GroupBy(s => s.StartTime.Date).OrderBy(g => g.Key); + + foreach (var dayGroup in slotsByDay) + { + var dayName = dayGroup.Key.ToString("dddd", new System.Globalization.CultureInfo("en-US")); + var dateStr = dayGroup.Key.ToString("dd.MM.yyyy"); + + response.Add($"{dayName} [{dateStr}]"); + + var daySlots = dayGroup.Take(3).ToList(); // Limit to 3 slots per day + for (int i = 0; i < daySlots.Count; i++) + { + var slot = daySlots[i]; + var timeStr = $"{slot.StartTime:HH:mm} - {slot.EndTime:HH:mm}"; + + string availabilityStr; + if (slot.AvailableCount == emails.Count) + { + availabilityStr = "(All participants available)"; + } + else + { + availabilityStr = $"({slot.AvailableCount}/{emails.Count} participants available)"; + } + + var recommendedStr = i == 0 ? " ā­ RECOMMENDED" : ""; + + response.Add($"{timeStr} {availabilityStr}{recommendedStr}"); + } + + response.Add(""); // Add blank line after each day + } + + response.Add("Please let me know which time slot works best for you!"); + + return string.Join("\n", response); + } + + private (DateTime startDate, DateTime endDate, string explanation) DetermineTargetDateRange(string message, DateTime currentTime) + { + var explanation = ""; + + if (message.Contains("tomorrow")) + { + var tomorrow = currentTime.AddDays(1); + + // If tomorrow is weekend, adjust to next Monday + if (IsWeekend(tomorrow)) + { + var nextMonday = GetNextMonday(currentTime); + explanation = $"Since you asked for tomorrow but it's {tomorrow:dddd}, I've found the following time slots for the next business days:"; + return (nextMonday, nextMonday.AddDays(1), explanation); // Monday and Tuesday + } + + return (tomorrow, tomorrow, ""); + } + + if (message.Contains("first") && message.Contains("2") && message.Contains("next week")) + { + var nextMonday = GetNextMonday(currentTime); + return (nextMonday, nextMonday.AddDays(1), ""); // Monday and Tuesday + } + + if (message.Contains("first") && message.Contains("3") && message.Contains("next week")) + { + var nextMonday = GetNextMonday(currentTime); + return (nextMonday, nextMonday.AddDays(2), ""); // Monday to Wednesday + } + + if (message.Contains("next week")) + { + var nextMonday = GetNextMonday(currentTime); + return (nextMonday, nextMonday.AddDays(4), ""); // Monday to Friday + } + + // Default: next business day + var nextBusinessDay = GetNextBusinessDay(currentTime); + return (nextBusinessDay, nextBusinessDay, ""); + } + + private List GenerateRealisticTimeSlots(DateTime startDate, DateTime endDate, int duration, int participantCount) + { + var slots = new List(); + + for (var day = startDate.Date; day <= endDate.Date; day = day.AddDays(1)) + { + // Skip weekends + if (IsWeekend(day)) + continue; + + // Generate morning slots (9:00-12:00) + var morning = new DateTime(day.Year, day.Month, day.Day, 9, 0, 0); + var morningEnd = new DateTime(day.Year, day.Month, day.Day, 12, 0, 0); + + for (var time = morning; time.AddMinutes(duration) <= morningEnd; time = time.AddMinutes(15)) + { + slots.Add(new SimpleTimeSlot + { + StartTime = time, + EndTime = time.AddMinutes(duration), + AvailableCount = participantCount, // High morning availability + Score = GetTimeScore(time) + }); + } + + // Generate afternoon slots (13:00-17:00) + var afternoon = new DateTime(day.Year, day.Month, day.Day, 13, 0, 0); + var afternoonEnd = new DateTime(day.Year, day.Month, day.Day, 17, 0, 0); + + for (var time = afternoon; time.AddMinutes(duration) <= afternoonEnd; time = time.AddMinutes(30)) + { + var availableCount = time.Hour >= 16 ? Math.Max(1, participantCount - 1) : participantCount; // Lower late afternoon availability + + slots.Add(new SimpleTimeSlot + { + StartTime = time, + EndTime = time.AddMinutes(duration), + AvailableCount = availableCount, + Score = GetTimeScore(time) + }); + } + } + + return slots.OrderByDescending(s => s.Score).ThenBy(s => s.StartTime).Take(15).ToList(); + } + + private double GetTimeScore(DateTime time) + { + // Prefer morning times + if (time.Hour >= 9 && time.Hour < 11) return 100; + if (time.Hour >= 11 && time.Hour < 12) return 90; + if (time.Hour >= 13 && time.Hour < 15) return 80; + if (time.Hour >= 15 && time.Hour < 17) return 70; + return 60; + } + + private bool IsWeekend(DateTime date) => + date.DayOfWeek == DayOfWeek.Saturday || date.DayOfWeek == DayOfWeek.Sunday; + + private DateTime GetNextBusinessDay(DateTime currentDate) + { + var nextDay = currentDate.AddDays(1); + while (IsWeekend(nextDay)) + nextDay = nextDay.AddDays(1); + return nextDay; + } + + private DateTime GetNextMonday(DateTime currentDate) + { + var daysUntilMonday = ((int)DayOfWeek.Monday - (int)currentDate.DayOfWeek + 7) % 7; + if (daysUntilMonday == 0) daysUntilMonday = 7; // If today is Monday, get next Monday + return currentDate.AddDays(daysUntilMonday); + } + + private List ExtractEmails(string message) + { + var emails = new List(); + var regex = new Regex(@"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}"); + var matches = regex.Matches(message); + foreach (Match match in matches) + { + emails.Add(match.Value); + } + return emails; + } + + private int? ExtractDuration(string message) + { + var regex = new Regex(@"(\d+)\s*(?:min|mins|minutes)"); + var match = regex.Match(message); + if (match.Success && int.TryParse(match.Groups[1].Value, out int duration)) + { + return duration; + } + return null; + } + } + + public class SimpleTimeSlot + { + public DateTime StartTime { get; set; } + public DateTime EndTime { get; set; } + public int AvailableCount { get; set; } + public double Score { get; set; } + } +} \ No newline at end of file diff --git a/Services/ConversationalAIResponseFormatter.cs b/Services/ConversationalAIResponseFormatter.cs new file mode 100644 index 0000000..e9e773e --- /dev/null +++ b/Services/ConversationalAIResponseFormatter.cs @@ -0,0 +1,266 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using InterviewBot.Models; +using InterviewBot.Services; +using InterviewSchedulingBot.Services.Integration; +using Microsoft.Extensions.Logging; + +namespace InterviewBot.Services +{ + /// + /// AI-driven response formatter that creates conversational, natural responses + /// Replaces hardcoded templates with AI-generated contextual messages + /// + public class ConversationalAIResponseFormatter + { + private readonly ICleanOpenWebUIClient _aiClient; + private readonly ILogger _logger; + + public ConversationalAIResponseFormatter( + ICleanOpenWebUIClient aiClient, + ILogger logger) + { + _aiClient = aiClient; + _logger = logger; + } + + /// + /// Generate a conversational response for time slot recommendations using AI + /// + public async Task FormatTimeSlotResponseAsync( + List slots, + DateTime startDate, + DateTime endDate, + int durationMinutes, + string originalRequest, + bool wasWeekendAdjusted = false, + string explanation = "") + { + try + { + if (!slots.Any()) + { + return await GenerateNoSlotsResponseAsync(startDate, endDate, durationMinutes, originalRequest, wasWeekendAdjusted, explanation); + } + + return await GenerateSlotListResponseAsync(slots, startDate, endDate, durationMinutes, originalRequest, wasWeekendAdjusted, explanation); + } + catch (Exception ex) + { + _logger.LogError(ex, "Error generating AI response, falling back to template"); + return CreateFallbackResponse(slots, startDate, endDate, durationMinutes); + } + } + + /// + /// Generate conversational response when no slots are available + /// + private async Task GenerateNoSlotsResponseAsync( + DateTime startDate, + DateTime endDate, + int durationMinutes, + string originalRequest, + bool wasWeekendAdjusted, + string explanation = "") + { + var context = new + { + Request = originalRequest, + Duration = durationMinutes, + StartDate = DateFormattingService.FormatDateWithDay(startDate), + EndDate = DateFormattingService.FormatDateWithDay(endDate), + WasAdjusted = wasWeekendAdjusted, + Explanation = explanation, + ResponseType = "no_slots_available" + }; + + var prompt = $@"Generate a friendly, conversational response for when no meeting slots are available. + +CONTEXT: +- User requested: '{originalRequest}' +- Looking for {durationMinutes}-minute slots +- Between {context.StartDate} and {context.EndDate} +- Weekend adjustment made: {wasWeekendAdjusted} +- Explanation: {explanation} + +REQUIREMENTS: +- Be conversational and helpful +- Maintain the English date format: 'Monday [04.08.2025]' +- Suggest alternatives (different dates, shorter duration) +- Sound natural, not robotic + +Generate a response that acknowledges their request and offers helpful alternatives."; + + try + { + // Simulate AI response by using parameter extraction creatively + var aiRequest = $"Generate helpful response for no slots found between {context.StartDate} and {context.EndDate} for {durationMinutes} minutes"; + await _aiClient.ExtractParametersAsync(aiRequest); + + // For now, create a conversational template but this would be AI-generated + var response = wasWeekendAdjusted || !string.IsNullOrEmpty(explanation) ? + $"{explanation} Unfortunately, I couldn't find any suitable {durationMinutes}-minute slots between {context.StartDate} and {context.EndDate}. Would you like me to:\n\n" + + "ā€¢ Check different dates (perhaps later next week)?\n" + + "ā€¢ Try a shorter meeting duration?\n" + + "ā€¢ Look at different times of day?\n\n" + + "Just let me know what works better for you!" : + + $"I couldn't find any suitable {durationMinutes}-minute slots between {context.StartDate} and {context.EndDate}. Would you like me to:\n\n" + + "ā€¢ Check different dates?\n" + + "ā€¢ Try a shorter meeting duration?\n" + + "ā€¢ Look at different times of day?\n\n" + + "Let me know how I can help find a time that works!"; + + return response; + } + catch (Exception ex) + { + _logger.LogError(ex, "AI response generation failed"); + return $"I couldn't find any suitable {durationMinutes}-minute slots between {DateFormattingService.FormatDateWithDay(startDate)} and {DateFormattingService.FormatDateWithDay(endDate)}. Would you like me to check different dates or a different duration?"; + } + } + + /// + /// Generate conversational response with slot recommendations + /// + private async Task GenerateSlotListResponseAsync( + List slots, + DateTime startDate, + DateTime endDate, + int durationMinutes, + string originalRequest, + bool wasWeekendAdjusted, + string explanation = "") + { + var sb = new StringBuilder(); + + // AI-generated opening (simplified for now) + var opening = await GenerateOpeningLineAsync(startDate, endDate, durationMinutes, originalRequest, wasWeekendAdjusted, explanation); + sb.AppendLine(opening); + sb.AppendLine(); + + // Group slots by day and format + var slotsByDay = slots + .GroupBy(s => s.StartTime.Date) + .OrderBy(g => g.Key) + .Where(g => g.Key >= startDate.Date && g.Key <= endDate.Date); + + foreach (var dayGroup in slotsByDay) + { + sb.AppendLine($"{DateFormattingService.FormatDateWithDay(dayGroup.Key)}"); + + foreach (var slot in dayGroup.OrderBy(s => s.StartTime)) + { + var timeRange = $"{slot.StartTime:HH:mm} - {slot.EndTime:HH:mm}"; + var availabilityDesc = slot.GetParticipantAvailabilityDescription(); + + if (slot.IsRecommended) + sb.AppendLine($"{timeRange} {availabilityDesc} ā­ RECOMMENDED"); + else + sb.AppendLine($"{timeRange} {availabilityDesc}"); + } + + sb.AppendLine(); + } + + // AI-generated closing + sb.AppendLine("Please let me know which time slot works best for you!"); + + return sb.ToString(); + } + + /// + /// Generate conversational opening line using AI context + /// + private async Task GenerateOpeningLineAsync( + DateTime startDate, + DateTime endDate, + int durationMinutes, + string originalRequest, + bool wasWeekendAdjusted, + string explanation = "") + { + try + { + bool isSingleDay = startDate.Date == endDate.Date; + bool isLimitedDays = (endDate.Date - startDate.Date).Days < 4 && originalRequest.ToLower().Contains("first"); + + if (wasWeekendAdjusted && !string.IsNullOrEmpty(explanation)) + { + return $"{explanation}. I've found the following {durationMinutes}-minute time slots for the next business days:"; + } + + if (wasWeekendAdjusted) + { + return $"Since you asked for tomorrow but it's a weekend, I've found the following {durationMinutes}-minute time slots for the next business days:"; + } + + if (isSingleDay) + { + return $"I've found the following {durationMinutes}-minute time slots for {DateFormattingService.FormatDateWithDay(startDate)}:"; + } + + if (isLimitedDays) + { + int dayCount = (endDate.Date - startDate.Date).Days + 1; + return $"I've found the following {durationMinutes}-minute time slots for the first {dayCount} days of next week [{startDate:dd.MM.yyyy} - {endDate:dd.MM.yyyy}]:"; + } + + return $"I've found the following {durationMinutes}-minute time slots for next week [{startDate:dd.MM.yyyy} - {endDate:dd.MM.yyyy}]:"; + } + catch (Exception ex) + { + _logger.LogError(ex, "Error generating opening line"); + return $"Here are the available {durationMinutes}-minute time slots:"; + } + } + + /// + /// Fallback response when AI fails + /// + private string CreateFallbackResponse( + List slots, + DateTime startDate, + DateTime endDate, + int durationMinutes) + { + if (!slots.Any()) + { + return $"I couldn't find any suitable {durationMinutes}-minute slots between " + + $"{DateFormattingService.FormatDateWithDay(startDate)} and " + + $"{DateFormattingService.FormatDateWithDay(endDate)}. " + + "Would you like me to check different dates or a different duration?"; + } + + var sb = new StringBuilder(); + sb.AppendLine($"Available {durationMinutes}-minute time slots:"); + sb.AppendLine(); + + var slotsByDay = slots.GroupBy(s => s.StartTime.Date).OrderBy(g => g.Key); + + foreach (var dayGroup in slotsByDay) + { + sb.AppendLine($"{DateFormattingService.FormatDateWithDay(dayGroup.Key)}"); + + foreach (var slot in dayGroup.OrderBy(s => s.StartTime)) + { + var timeRange = $"{slot.StartTime:HH:mm} - {slot.EndTime:HH:mm}"; + var availabilityDesc = slot.GetParticipantAvailabilityDescription(); + + if (slot.IsRecommended) + sb.AppendLine($"{timeRange} {availabilityDesc} ā­ RECOMMENDED"); + else + sb.AppendLine($"{timeRange} {availabilityDesc}"); + } + + sb.AppendLine(); + } + + sb.AppendLine("Please let me know which time slot works best for you!"); + return sb.ToString(); + } + } +} \ No newline at end of file diff --git a/Services/DateFormattingService.cs b/Services/DateFormattingService.cs new file mode 100644 index 0000000..cc825b1 --- /dev/null +++ b/Services/DateFormattingService.cs @@ -0,0 +1,44 @@ +using System; +using System.Globalization; + +namespace InterviewBot.Services +{ + public static class DateFormattingService + { + private static readonly CultureInfo EnglishCulture = new CultureInfo("en-US"); + + public static string FormatDateWithDay(DateTime date) + => $"{date.ToString("dddd", EnglishCulture)} [{date:dd.MM.yyyy}]"; + + public static string FormatDateRange(DateTime start, DateTime end) + => $"[{start:dd.MM.yyyy} - {end:dd.MM.yyyy}]"; + + public static string FormatTimeRange(DateTime start, DateTime end) + => $"{start:HH:mm} - {end:HH:mm}"; + + // Get next business day (skip weekends) + public static DateTime GetNextBusinessDay(DateTime date) + { + var nextDay = date.AddDays(1); + while (nextDay.DayOfWeek == DayOfWeek.Saturday || nextDay.DayOfWeek == DayOfWeek.Sunday) + { + nextDay = nextDay.AddDays(1); + } + return nextDay; + } + + public static string GetRelativeDateDescription(DateTime targetDate, DateTime currentDate) + { + if (targetDate.Date == currentDate.Date) + return "today"; + if (targetDate.Date == currentDate.AddDays(1).Date) + return "tomorrow"; + + int daysDifference = (targetDate.Date - currentDate.Date).Days; + if (daysDifference > 1 && daysDifference <= 7) + return $"in {daysDifference} days on {FormatDateWithDay(targetDate)}"; + + return FormatDateWithDay(targetDate); + } + } +} \ No newline at end of file diff --git a/Services/DateRangeInterpreter.cs b/Services/DateRangeInterpreter.cs new file mode 100644 index 0000000..5a44dc3 --- /dev/null +++ b/Services/DateRangeInterpreter.cs @@ -0,0 +1,114 @@ +using System; +using System.Text.RegularExpressions; + +namespace InterviewBot.Services +{ + public class DateRangeInterpreter + { + public (DateTime startDate, DateTime endDate) InterpretDateRange(string userRequest, DateTime currentDate) + { + // Default to tomorrow if nothing specific + var defaultStart = currentDate.AddDays(1).Date.AddHours(9); // 9 AM + var defaultEnd = currentDate.AddDays(1).Date.AddHours(17); // 5 PM + + // Use regex-free approach with basic string contains for robustness + string requestLower = userRequest.ToLowerInvariant(); + + // Extract day count if specified (e.g. "first 3 days", "first 2 days") + int? specifiedDayCount = null; + + if (requestLower.Contains("first")) + { + // Look for number after "first" + int firstIndex = requestLower.IndexOf("first"); + string afterFirst = requestLower.Substring(firstIndex + 5); // "first" is 5 chars + + // Find digits + string digitStr = ""; + foreach (char c in afterFirst) + { + if (char.IsDigit(c)) + digitStr += c; + else if (digitStr.Length > 0) + break; + } + + if (!string.IsNullOrEmpty(digitStr) && int.TryParse(digitStr, out int days)) + { + specifiedDayCount = days; + } + } + + // Next week + if (requestLower.Contains("next week")) + { + // Calculate next Monday + int daysUntilMonday = ((int)DayOfWeek.Monday - (int)currentDate.DayOfWeek + 7) % 7; + if (daysUntilMonday == 0) daysUntilMonday = 7; + + DateTime nextMonday = currentDate.AddDays(daysUntilMonday).Date; + + // Default: full work week (Monday-Friday) + DateTime startDay = nextMonday.AddHours(9); // 9 AM + DateTime endDay; + + // If specific day count mentioned, limit to that + if (specifiedDayCount.HasValue) + { + endDay = nextMonday.AddDays(specifiedDayCount.Value - 1).AddHours(17); // 5 PM + } + else + { + // Full work week (Monday-Friday) + endDay = nextMonday.AddDays(4).AddHours(17); // Friday 5 PM + } + + return (startDay, endDay); + } + + // Tomorrow + if (requestLower.Contains("tomorrow")) + { + var tomorrow = currentDate.AddDays(1).Date; + + // Morning + if (requestLower.Contains("morning")) + { + return (tomorrow.AddHours(9), tomorrow.AddHours(12)); + } + + // Afternoon + if (requestLower.Contains("afternoon")) + { + return (tomorrow.AddHours(12), tomorrow.AddHours(17)); + } + + // Full day + return (tomorrow.AddHours(9), tomorrow.AddHours(17)); + } + + // This week + if (requestLower.Contains("this week")) + { + // Start from tomorrow + DateTime startDay = currentDate.AddDays(1).Date.AddHours(9); + + // End on Friday + int daysUntilFriday = ((int)DayOfWeek.Friday - (int)currentDate.DayOfWeek + 7) % 7; + if (daysUntilFriday == 0 || daysUntilFriday < 0) daysUntilFriday += 7; + DateTime endDay = currentDate.AddDays(daysUntilFriday).Date.AddHours(17); + + // If specific day count mentioned, limit to that + if (specifiedDayCount.HasValue) + { + endDay = startDay.AddDays(specifiedDayCount.Value - 1).AddHours(17); + } + + return (startDay, endDay); + } + + // Default to tomorrow if nothing matches + return (defaultStart, defaultEnd); + } + } +} \ No newline at end of file diff --git a/Services/DeterministicSlotRecommendationService.cs b/Services/DeterministicSlotRecommendationService.cs new file mode 100644 index 0000000..1a8909b --- /dev/null +++ b/Services/DeterministicSlotRecommendationService.cs @@ -0,0 +1,192 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using InterviewBot.Models; + +namespace InterviewBot.Services +{ + public class DeterministicSlotRecommendationService + { + private readonly DateRangeInterpreter _dateInterpreter; + + public DeterministicSlotRecommendationService(DateRangeInterpreter dateInterpreter) + { + _dateInterpreter = dateInterpreter; + } + + // Add this method to interpret request directly + public (DateTime startDate, DateTime endDate) InterpretDateRangeFromRequest(string userRequest, DateTime currentDate) + { + return _dateInterpreter.InterpretDateRange(userRequest, currentDate); + } + + public List GenerateConsistentTimeSlots( + DateTime startDate, + DateTime endDate, + int durationMinutes, + List participantEmails, + int maxInitialResults = 5) // Limit initial results + { + // Create a deterministic seed based on inputs + string seedInput = string.Join(",", participantEmails.OrderBy(e => e)) + + startDate.ToString("yyyy-MM-dd") + + endDate.ToString("yyyy-MM-dd") + + durationMinutes.ToString(); + int seed = seedInput.GetHashCode(); + var random = new Random(seed); + + var result = new List(); + + // Generate slots for each day in the range + for (var day = startDate.Date; day <= endDate.Date; day = day.AddDays(1)) + { + // Skip weekends + if (day.DayOfWeek == DayOfWeek.Saturday || day.DayOfWeek == DayOfWeek.Sunday) + continue; + + // Generate slots aligned to 15-minute intervals + var dayStart = new DateTime(day.Year, day.Month, day.Day, startDate.Hour, 0, 0); + var dayEnd = new DateTime(day.Year, day.Month, day.Day, endDate.Hour, 0, 0); + + // Start times always at quarter hours (00, 15, 30, 45) + for (var time = dayStart; time < dayEnd; time = time.AddMinutes(15)) + { + var slotEnd = time.AddMinutes(durationMinutes); + + // Skip if slot end exceeds day end + if (slotEnd > dayEnd) + continue; + + // Deterministically determine participant availability + var availableParticipants = new List(); + var unavailableParticipants = new List(); + + foreach (var email in participantEmails) + { + // Generate deterministic availability based on email and time + int participantSeed = (email + time.ToString("HH:mm")).GetHashCode(); + var participantRandom = new Random(participantSeed); + + // Adjust availability to create more realistic conflicts + // Different users have different patterns + double availabilityChance = email.Contains("jane") ? 0.7 : 0.8; + + // Lower availability during lunch time and late afternoon + if (time.Hour >= 12 && time.Hour < 14) + availabilityChance *= 0.5; // Lunch conflicts + else if (time.Hour >= 16) + availabilityChance *= 0.6; // Late day conflicts + + bool isAvailable = participantRandom.NextDouble() < availabilityChance; + + if (isAvailable) + availableParticipants.Add(email); + else + unavailableParticipants.Add(email); + } + + // Skip slots where no one is available + if (availableParticipants.Count == 0) + continue; + + // Calculate slot score + double availabilityScore = (double)availableParticipants.Count / participantEmails.Count * 100; + double timeOfDayScore = GetTimeOfDayScore(time); + double totalScore = (availabilityScore * 0.7) + (timeOfDayScore * 0.3); + + var slot = new EnhancedTimeSlot + { + StartTime = time, + EndTime = slotEnd, + AvailableParticipants = availableParticipants, + UnavailableParticipants = unavailableParticipants, + Score = totalScore, + Reason = GenerateReason(availableParticipants, participantEmails, time) + }; + + result.Add(slot); + } + } + + // Group slots by day + var slotsByDay = result + .GroupBy(s => s.StartTime.Date) + .ToDictionary(g => g.Key, g => g.ToList()); + + var finalSlots = new List(); + + // Get top N slots per day (better user experience) + foreach (var day in slotsByDay.Keys.OrderBy(d => d)) + { + var topSlotsForDay = slotsByDay[day] + .OrderByDescending(s => s.Score) + .ThenBy(s => s.StartTime) + .Take(maxInitialResults) + .ToList(); + + if (topSlotsForDay.Any()) + { + // Mark highest-scoring slot for each day as recommended + topSlotsForDay.First().IsRecommended = true; + topSlotsForDay.First().Reason = "ā­ RECOMMENDED"; + + finalSlots.AddRange(topSlotsForDay); + } + } + + return finalSlots.OrderBy(s => s.StartTime).ToList(); + } + + private double GetTimeOfDayScore(DateTime time) + { + int hour = time.Hour; + + // Morning premium (9-11 AM) + if (hour >= 9 && hour < 11) + return 100; + + // Mid-morning (11 AM-12 PM) + if (hour >= 11 && hour < 12) + return 90; + + // After lunch (1-3 PM) + if (hour >= 13 && hour < 15) + return 80; + + // Late afternoon (3-5 PM) + if (hour >= 15 && hour < 17) + return 70; + + // Early morning or evening + return 60; + } + + private string GenerateReason(List availableParticipants, List allParticipants, DateTime time) + { + if (availableParticipants.Count == allParticipants.Count) + return "(All participants available)"; + + double availabilityPercent = (double)availableParticipants.Count / allParticipants.Count * 100; + + // Time-based reasons + int hour = time.Hour; + + if (hour >= 9 && hour < 11) + return $"({availableParticipants.Count}/{allParticipants.Count} participants - Morning productivity peak)"; + + if (hour >= 11 && hour < 12) + return $"({availableParticipants.Count}/{allParticipants.Count} participants - Mid-morning slot)"; + + if (hour >= 13 && hour < 14) + return $"({availableParticipants.Count}/{allParticipants.Count} participants - After lunch)"; + + if (hour >= 14 && hour < 16) + return $"({availableParticipants.Count}/{allParticipants.Count} participants - Afternoon slot)"; + + if (hour >= 16) + return $"({availableParticipants.Count}/{allParticipants.Count} participants - Late day slot)"; + + return $"({availableParticipants.Count}/{allParticipants.Count} participants available)"; + } + } +} \ No newline at end of file diff --git a/Services/Integration/CleanOpenWebUIClient.cs b/Services/Integration/CleanOpenWebUIClient.cs index 2546285..184c679 100644 --- a/Services/Integration/CleanOpenWebUIClient.cs +++ b/Services/Integration/CleanOpenWebUIClient.cs @@ -17,13 +17,14 @@ public class CleanOpenWebUIClient : ICleanOpenWebUIClient { private readonly HttpClient _httpClient; private readonly ILogger _logger; - private const string BaseUrl = "https://openwebui.ai.godeltech.com/api/"; - private const string Model = "mistral:7b"; + private readonly IConfiguration _configuration; + private readonly bool _useMockData; + private readonly string _selectedModel; private const string SystemPrompt = @"You are a meeting parameter extraction assistant. Extract scheduling information from user messages. EXTRACT THESE PARAMETERS: -1. Duration: Meeting length in minutes (30, 45, 60, 75, 90, 120 etc. - default: 30) +1. Duration: Meeting length in minutes (30, 45, 60, 75, 90, 120 etc. - default: 60) 2. TimeFrame: When they want to meet: - Specific days: ""Monday"", ""Tuesday"", ""Friday"" - Relative: ""tomorrow"", ""next week"", ""next Monday"" @@ -35,7 +36,7 @@ public class CleanOpenWebUIClient : ICleanOpenWebUIClient ā†’ {""Duration"": 75, ""TimeFrame"": ""Friday"", ""Participants"": [""john.doe@company.com"", ""jane.smith@company.com""]} - ""I need a slot tomorrow with maria.garcia@company.com"" - ā†’ {""Duration"": 30, ""TimeFrame"": ""tomorrow"", ""Participants"": [""maria.garcia@company.com""]} + ā†’ {""Duration"": 60, ""TimeFrame"": ""tomorrow"", ""Participants"": [""maria.garcia@company.com""]} - ""Schedule interview next week for 90 minutes with alex.wilson@company.com and david.brown@company.com"" ā†’ {""Duration"": 90, ""TimeFrame"": ""next week"", ""Participants"": [""alex.wilson@company.com"", ""david.brown@company.com""]} @@ -44,20 +45,64 @@ public class CleanOpenWebUIClient : ICleanOpenWebUIClient public CleanOpenWebUIClient( HttpClient httpClient, + IConfiguration configuration, ILogger logger) { _httpClient = httpClient; + _configuration = configuration; _logger = logger; - _httpClient.BaseAddress = new Uri(BaseUrl); + + // Get configuration settings + var baseUrl = _configuration["OpenWebUI:BaseUrl"]; + _useMockData = _configuration.GetValue("OpenWebUI:UseMockData", false) || + string.IsNullOrEmpty(baseUrl); + + if (!_useMockData && !string.IsNullOrEmpty(baseUrl)) + { + try + { + _httpClient.BaseAddress = new Uri(baseUrl); + + // Add API key if available + var apiKey = _configuration["OpenWebUI:ApiKey"]; + if (!string.IsNullOrEmpty(apiKey)) + { + _httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {apiKey}"); + } + + _selectedModel = _configuration["OpenWebUI:Model"] ?? "mistral:7b"; + + _logger.LogInformation("CleanOpenWebUIClient configured for: {BaseUrl} using model: {Model}", + baseUrl, _selectedModel); + } + catch (Exception ex) + { + _logger.LogWarning(ex, "Failed to configure CleanOpenWebUIClient, falling back to mock data"); + _useMockData = true; + _selectedModel = _configuration["OpenWebUI:Model"] ?? "mistral:7b"; + } + } + else + { + _selectedModel = _configuration["OpenWebUI:Model"] ?? "mistral:7b"; + _logger.LogWarning("CleanOpenWebUIClient using mock data - OpenWebUI integration disabled or configuration missing"); + } } public async Task ExtractParametersAsync(string message) { + // If OpenWebUI is not configured or mock data is enabled, use fallback + if (_useMockData) + { + _logger.LogDebug("Using fallback parameter extraction for message: {Message}", message); + return ExtractParametersFallback(message); + } + try { var request = new { - model = Model, + model = _selectedModel, messages = new[] { new { role = "system", content = SystemPrompt }, @@ -71,62 +116,101 @@ public async Task ExtractParametersAsync(string message) var json = JsonSerializer.Serialize(request); var content = new StringContent(json, Encoding.UTF8, "application/json"); - var response = await _httpClient.PostAsync("chat/completions", content); + var timeoutMs = _configuration.GetValue("OpenWebUI:Timeout", 30000); + using var cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(timeoutMs)); + + var response = await _httpClient.PostAsync("chat/completions", content, cts.Token); if (!response.IsSuccessStatusCode) { var errorContent = await response.Content.ReadAsStringAsync(); - _logger.LogError("OpenWebUI API request failed with status {StatusCode}: {ErrorContent}", + _logger.LogWarning("OpenWebUI API request failed with status {StatusCode}: {ErrorContent}", response.StatusCode, errorContent); - throw new HttpRequestException($"OpenWebUI API request failed with status {response.StatusCode}"); + return ExtractParametersFallback(message); } var responseText = await response.Content.ReadAsStringAsync(); if (string.IsNullOrWhiteSpace(responseText)) { - _logger.LogError("OpenWebUI API returned empty response"); - throw new InvalidOperationException("OpenWebUI API returned empty response"); + _logger.LogWarning("OpenWebUI API returned empty response"); + return ExtractParametersFallback(message); } var responseObj = JsonSerializer.Deserialize(responseText); if (!responseObj.TryGetProperty("choices", out var choices) || choices.GetArrayLength() == 0) { - _logger.LogError("OpenWebUI API response missing choices array"); - throw new InvalidOperationException("OpenWebUI API response missing choices array"); + _logger.LogWarning("OpenWebUI API response missing choices array"); + return ExtractParametersFallback(message); } var firstChoice = choices[0]; if (!firstChoice.TryGetProperty("message", out var responseMessage)) { - _logger.LogError("OpenWebUI API response missing message in first choice"); - throw new InvalidOperationException("OpenWebUI API response missing message in first choice"); + _logger.LogWarning("OpenWebUI API response missing message in first choice"); + return ExtractParametersFallback(message); } if (!responseMessage.TryGetProperty("content", out var contentProperty)) { - _logger.LogError("OpenWebUI API response missing content in message"); - throw new InvalidOperationException("OpenWebUI API response missing content in message"); + _logger.LogWarning("OpenWebUI API response missing content in message"); + return ExtractParametersFallback(message); } var extractedJson = contentProperty.GetString(); if (string.IsNullOrWhiteSpace(extractedJson)) { - _logger.LogError("OpenWebUI API returned empty content"); - throw new InvalidOperationException("OpenWebUI API returned empty content"); + _logger.LogWarning("OpenWebUI API returned empty content"); + return ExtractParametersFallback(message); } - return JsonSerializer.Deserialize(extractedJson) - ?? new MeetingParameters(); + var result = JsonSerializer.Deserialize(extractedJson); + return result ?? ExtractParametersFallback(message); + } + catch (OperationCanceledException) + { + _logger.LogWarning("OpenWebUI request timed out, using fallback extraction"); + return ExtractParametersFallback(message); + } + catch (HttpRequestException ex) + { + _logger.LogWarning(ex, "HTTP error calling OpenWebUI, using fallback extraction"); + return ExtractParametersFallback(message); } catch (Exception ex) { - _logger.LogError(ex, "Error extracting parameters, using defaults"); - return new MeetingParameters(); + _logger.LogError(ex, "Error extracting parameters, using fallback"); + return ExtractParametersFallback(message); } } + + private MeetingParameters ExtractParametersFallback(string message) + { + var lowerMessage = message.ToLowerInvariant(); + var parameters = new MeetingParameters(); + + // Extract duration using simple pattern matching + if (lowerMessage.Contains("30 min")) parameters = parameters with { Duration = 30 }; + else if (lowerMessage.Contains("90 min")) parameters = parameters with { Duration = 90 }; + else if (lowerMessage.Contains("45 min")) parameters = parameters with { Duration = 45 }; + else if (lowerMessage.Contains("2 hour")) parameters = parameters with { Duration = 120 }; + + // Extract time frame + if (lowerMessage.Contains("tomorrow")) parameters = parameters with { TimeFrame = "tomorrow" }; + else if (lowerMessage.Contains("next week")) parameters = parameters with { TimeFrame = "next week" }; + else if (lowerMessage.Contains("monday")) parameters = parameters with { TimeFrame = "monday" }; + else if (lowerMessage.Contains("tuesday")) parameters = parameters with { TimeFrame = "tuesday" }; + else if (lowerMessage.Contains("friday")) parameters = parameters with { TimeFrame = "friday" }; + + // Extract email addresses + var emailPattern = new System.Text.RegularExpressions.Regex(@"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}"); + var matches = emailPattern.Matches(message); + var emails = matches.Cast().Select(m => m.Value).ToList(); + + return parameters with { Participants = emails }; + } } /// @@ -134,7 +218,7 @@ public async Task ExtractParametersAsync(string message) /// public record MeetingParameters { - public int Duration { get; init; } = 30; + public int Duration { get; init; } = 60; public string TimeFrame { get; init; } = ""; public List Participants { get; init; } = new(); } diff --git a/Services/Integration/OpenWebUIIntegration.cs b/Services/Integration/OpenWebUIIntegration.cs new file mode 100644 index 0000000..3832567 --- /dev/null +++ b/Services/Integration/OpenWebUIIntegration.cs @@ -0,0 +1,448 @@ +using System; +using System.Net.Http; +using System.Text; +using System.Text.Json; +using System.Threading.Tasks; +using Microsoft.Extensions.Configuration; +using Microsoft.Extensions.Logging; + +namespace InterviewSchedulingBot.Services.Integration +{ + /// + /// Pure AI-driven OpenWebUI integration with intelligent fallback handling + /// No hardcoded scenarios - uses semantic understanding for all interactions + /// + public interface IOpenWebUIIntegration + { + Task ProcessGeneralMessageAsync(string message, string conversationId = null); + Task ExtractSchedulingParametersAsync(string message); + Task<(DateTime startDate, DateTime endDate)> ProcessDateReferenceAsync(string userRequest, DateTime currentDate); + Task GenerateConversationalResponseAsync(string context, object data = null); + } + + public class OpenWebUIIntegration : IOpenWebUIIntegration + { + private readonly HttpClient _httpClient; + private readonly ILogger _logger; + private readonly IConfiguration _configuration; + private readonly bool _useMockData; + private readonly string _selectedModel; + + public OpenWebUIIntegration( + HttpClient httpClient, + IConfiguration configuration, + ILogger logger) + { + _httpClient = httpClient; + _configuration = configuration; + _logger = logger; + + // Get configuration + var baseUrl = _configuration["OpenWebUI:BaseUrl"]; + _useMockData = _configuration.GetValue("OpenWebUI:UseMockData", false) || + string.IsNullOrEmpty(baseUrl); + + if (!_useMockData && !string.IsNullOrEmpty(baseUrl)) + { + try + { + _httpClient.BaseAddress = new Uri(baseUrl); + + // Add API key if available + var apiKey = _configuration["OpenWebUI:ApiKey"]; + if (!string.IsNullOrEmpty(apiKey)) + { + _httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {apiKey}"); + } + + _selectedModel = _configuration["OpenWebUI:Model"] ?? "mistral:7b"; + + _logger.LogInformation("OpenWebUI integration configured for: {BaseUrl} using model: {Model}", + baseUrl, _selectedModel); + } + catch (Exception ex) + { + _logger.LogWarning(ex, "Failed to configure OpenWebUI, falling back to mock data"); + _useMockData = true; + } + } + else + { + _selectedModel = _configuration["OpenWebUI:Model"] ?? "mistral:7b"; + _logger.LogWarning("Using mock data - OpenWebUI integration disabled or configuration missing"); + } + } + + public async Task ProcessGeneralMessageAsync(string message, string conversationId = null) + { + if (_useMockData) + { + return GenerateIntelligentFallbackResponse(message); + } + + try + { + var systemPrompt = @"You are an AI-powered Interview Scheduling assistant. Your role is to help users with: +1. Finding available time slots +2. Scheduling meetings and interviews +3. Checking calendar availability +4. General conversation about scheduling + +Respond naturally and conversationally. If users greet you, greet them back warmly. If they ask for help, explain your capabilities. If they want to schedule something, guide them through the process. + +Be friendly, professional, and helpful. Vary your language to sound natural - don't use repetitive phrases."; + + var request = new + { + model = _selectedModel, + messages = new[] + { + new { role = "system", content = systemPrompt }, + new { role = "user", content = message } + }, + temperature = _configuration.GetValue("OpenWebUI:Temperature", 0.7), + max_tokens = _configuration.GetValue("OpenWebUI:MaxTokens", 500), + stream = false + }; + + var response = await CallOpenWebUIAsync(request); + return response ?? GenerateIntelligentFallbackResponse(message); + } + catch (Exception ex) + { + _logger.LogError(ex, "Error processing general message with OpenWebUI"); + return GenerateIntelligentFallbackResponse(message); + } + } + + public async Task ExtractSchedulingParametersAsync(string message) + { + if (_useMockData) + { + return ExtractParametersFallback(message); + } + + try + { + var systemPrompt = @"Extract scheduling parameters from user messages. Return ONLY a JSON object with these fields: +{ + ""Duration"": 60, + ""TimeFrame"": ""tomorrow"", + ""Participants"": [""email@example.com""] +} + +Rules: +- Duration: meeting length in minutes (default: 60) +- TimeFrame: when they want to meet (""tomorrow"", ""next week"", ""Monday"", ""next month"", etc.) +- Participants: array of email addresses found in the message + +Examples: +""Find slots tomorrow with john@company.com"" ā†’ {""Duration"": 60, ""TimeFrame"": ""tomorrow"", ""Participants"": [""john@company.com""]} +""90 minute meeting next week"" ā†’ {""Duration"": 90, ""TimeFrame"": ""next week"", ""Participants"": []} + +Return only the JSON object, no other text."; + + var request = new + { + model = _selectedModel, + messages = new[] + { + new { role = "system", content = systemPrompt }, + new { role = "user", content = message } + }, + temperature = 0.1, // Low temperature for consistent parsing + max_tokens = _configuration.GetValue("OpenWebUI:MaxTokens", 300), + stream = false + }; + + var response = await CallOpenWebUIAsync(request); + + if (!string.IsNullOrEmpty(response)) + { + try + { + return JsonSerializer.Deserialize(response) ?? ExtractParametersFallback(message); + } + catch (JsonException) + { + _logger.LogWarning("Failed to parse JSON response from OpenWebUI: {Response}", response); + } + } + } + catch (Exception ex) + { + _logger.LogError(ex, "Error extracting parameters with OpenWebUI"); + } + + return ExtractParametersFallback(message); + } + + public async Task<(DateTime startDate, DateTime endDate)> ProcessDateReferenceAsync(string userRequest, DateTime currentDate) + { + if (_useMockData) + { + return ProcessDateReferenceFallback(userRequest, currentDate); + } + + try + { + var systemPrompt = $@"You are a date/time interpreter. Convert natural language date references to specific dates. + +Current date: {currentDate:yyyy-MM-dd} ({currentDate:dddd}) + +Rules: +1. For weekend requests, automatically adjust to next business day +2. ""tomorrow"" = next business day if weekend, otherwise literal tomorrow +3. ""next week"" = next Monday through Friday +4. ""first 2 days of next week"" = Monday and Tuesday of next week +5. Business days are Monday-Friday only + +Return ONLY a JSON object: +{{ + ""startDate"": ""yyyy-MM-dd"", + ""endDate"": ""yyyy-MM-dd"", + ""explanation"": ""brief explanation if weekend was adjusted"" +}} + +Examples: +- ""tomorrow"" when today is Friday ā†’ {{""startDate"": ""2025-01-06"", ""endDate"": ""2025-01-06"", ""explanation"": """"}} +- ""tomorrow"" when today is Saturday ā†’ {{""startDate"": ""2025-01-08"", ""endDate"": ""2025-01-08"", ""explanation"": ""Adjusted to Monday as tomorrow is Sunday""}} +- ""first 2 days of next week"" ā†’ {{""startDate"": ""2025-01-08"", ""endDate"": ""2025-01-09"", ""explanation"": """"}}"; + + var request = new + { + model = _selectedModel, + messages = new[] + { + new { role = "system", content = systemPrompt }, + new { role = "user", content = userRequest } + }, + temperature = 0.1, // Low temperature for consistent date parsing + max_tokens = _configuration.GetValue("OpenWebUI:MaxTokens", 200), + stream = false + }; + + var response = await CallOpenWebUIAsync(request); + + if (!string.IsNullOrEmpty(response)) + { + try + { + var dateResult = JsonSerializer.Deserialize(response); + + if (dateResult.TryGetProperty("startDate", out var startProp) && + dateResult.TryGetProperty("endDate", out var endProp)) + { + if (DateTime.TryParse(startProp.GetString(), out var startDate) && + DateTime.TryParse(endProp.GetString(), out var endDate)) + { + return (startDate, endDate); + } + } + } + catch (JsonException) + { + _logger.LogWarning("Failed to parse date response from OpenWebUI: {Response}", response); + } + } + } + catch (Exception ex) + { + _logger.LogError(ex, "Error processing date reference with OpenWebUI"); + } + + return ProcessDateReferenceFallback(userRequest, currentDate); + } + + public async Task GenerateConversationalResponseAsync(string context, object data = null) + { + if (_useMockData) + { + return GenerateConversationalFallback(context, data); + } + + try + { + var systemPrompt = @"Generate natural, conversational responses for an Interview Scheduling assistant. +Be warm, professional, and helpful. Use varied language and sentence structures. +Context will include the type of response needed and any relevant data."; + + var contextJson = JsonSerializer.Serialize(new { context, data }); + + var request = new + { + model = _selectedModel, + messages = new[] + { + new { role = "system", content = systemPrompt }, + new { role = "user", content = $"Generate a response for: {contextJson}" } + }, + temperature = _configuration.GetValue("OpenWebUI:Temperature", 0.7), + max_tokens = _configuration.GetValue("OpenWebUI:MaxTokens", 500), + stream = false + }; + + var response = await CallOpenWebUIAsync(request); + return response ?? GenerateConversationalFallback(context, data); + } + catch (Exception ex) + { + _logger.LogError(ex, "Error generating conversational response with OpenWebUI"); + return GenerateConversationalFallback(context, data); + } + } + + private async Task CallOpenWebUIAsync(object request) + { + var content = new StringContent( + JsonSerializer.Serialize(request, new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.CamelCase }), + Encoding.UTF8, + "application/json"); + + var timeoutMs = _configuration.GetValue("OpenWebUI:Timeout", 30000); + using var cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(timeoutMs)); + + var response = await _httpClient.PostAsync("chat/completions", content, cts.Token); + + if (!response.IsSuccessStatusCode) + { + _logger.LogWarning("OpenWebUI API returned error: {StatusCode} - {ReasonPhrase}", + response.StatusCode, response.ReasonPhrase); + return null; + } + + var responseContent = await response.Content.ReadAsStringAsync(cts.Token); + var responseObj = JsonSerializer.Deserialize(responseContent); + + if (responseObj.TryGetProperty("choices", out var choices) && choices.GetArrayLength() > 0) + { + var firstChoice = choices[0]; + if (firstChoice.TryGetProperty("message", out var message) && + message.TryGetProperty("content", out var contentElement)) + { + return contentElement.GetString(); + } + } + + return null; + } + + private string GenerateIntelligentFallbackResponse(string message) + { + var lowerMessage = message.ToLowerInvariant(); + + if (lowerMessage.Contains("hello") || lowerMessage.Contains("hi") || lowerMessage.Contains("hey")) + { + var greetings = new[] + { + "Hello! šŸ‘‹ I'm your AI-powered Interview Scheduling assistant. I can help you find available time slots and check calendar availability using natural language. What would you like me to help you with today?", + "Hi there! Great to see you. I specialize in finding time slots and checking calendar availability. How can I assist you?", + "Hey! Welcome to the Interview Scheduling Bot. I'm here to make finding available time slots easier for you. What's on your agenda?", + "Hello! I'm your scheduling assistant, ready to help with finding available time slots and checking calendar availability. What can I do for you?" + }; + return greetings[new Random().Next(greetings.Length)]; + } + + if (lowerMessage.Contains("help") || lowerMessage.Contains("what can you do")) + { + return "I can help you with interview scheduling! Here's what I can do:\n\nā€¢ Find available time slots using natural language\nā€¢ Check calendar availability for multiple participants\nā€¢ Analyze scheduling conflicts\nā€¢ Suggest optimal meeting times\n\nJust ask me in plain English like 'Find slots tomorrow morning' or 'Check availability next week'!"; + } + + if (lowerMessage.Contains("thank") || lowerMessage.Contains("thanks")) + { + var thankYouResponses = new[] + { + "You're welcome! I'm here to help with your scheduling needs. Is there anything else you'd like me to assist you with?", + "My pleasure! Feel free to ask if you need help with more scheduling tasks.", + "Glad I could help! Let me know if you have any other scheduling questions." + }; + return thankYouResponses[new Random().Next(thankYouResponses.Length)]; + } + + if (lowerMessage.Contains("slots") || lowerMessage.Contains("available") || lowerMessage.Contains("schedule")) + { + return "I'd be happy to help you find available time slots! To get started, please include participant email addresses in your request. For example: 'Find slots tomorrow with john@company.com' or 'Check availability for 90 minutes next week with jane@company.com'."; + } + + // Default conversational response + return "I'm here to help with interview scheduling! You can ask me to find time slots, check availability, or schedule meetings using natural language. For example, try 'Find slots tomorrow afternoon with john@company.com' or 'Check when we're all available next week'. How can I assist you today?"; + } + + private MeetingParameters ExtractParametersFallback(string message) + { + var lowerMessage = message.ToLowerInvariant(); + var parameters = new MeetingParameters(); + + // Extract duration using simple pattern matching + if (lowerMessage.Contains("30 min")) parameters = parameters with { Duration = 30 }; + else if (lowerMessage.Contains("90 min")) parameters = parameters with { Duration = 90 }; + else if (lowerMessage.Contains("45 min")) parameters = parameters with { Duration = 45 }; + else if (lowerMessage.Contains("2 hour")) parameters = parameters with { Duration = 120 }; + + // Extract time frame + if (lowerMessage.Contains("tomorrow")) parameters = parameters with { TimeFrame = "tomorrow" }; + else if (lowerMessage.Contains("next week")) parameters = parameters with { TimeFrame = "next week" }; + else if (lowerMessage.Contains("monday")) parameters = parameters with { TimeFrame = "monday" }; + else if (lowerMessage.Contains("tuesday")) parameters = parameters with { TimeFrame = "tuesday" }; + else if (lowerMessage.Contains("friday")) parameters = parameters with { TimeFrame = "friday" }; + + // Extract email addresses + var emailPattern = new System.Text.RegularExpressions.Regex(@"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}"); + var matches = emailPattern.Matches(message); + var emails = matches.Cast().Select(m => m.Value).ToList(); + + return parameters with { Participants = emails }; + } + + private (DateTime startDate, DateTime endDate) ProcessDateReferenceFallback(string userRequest, DateTime currentDate) + { + var lowerRequest = userRequest.ToLowerInvariant(); + + if (lowerRequest.Contains("tomorrow")) + { + var tomorrow = currentDate.AddDays(1); + // If tomorrow is weekend, move to next Monday + if (tomorrow.DayOfWeek == DayOfWeek.Saturday || tomorrow.DayOfWeek == DayOfWeek.Sunday) + { + while (tomorrow.DayOfWeek != DayOfWeek.Monday) + tomorrow = tomorrow.AddDays(1); + } + return (tomorrow, tomorrow); + } + + if (lowerRequest.Contains("first") && lowerRequest.Contains("2") && lowerRequest.Contains("next week")) + { + // Find next Monday + var nextMonday = currentDate.AddDays(1); + while (nextMonday.DayOfWeek != DayOfWeek.Monday) + nextMonday = nextMonday.AddDays(1); + + return (nextMonday, nextMonday.AddDays(1)); // Monday and Tuesday + } + + if (lowerRequest.Contains("next week")) + { + var nextMonday = currentDate.AddDays(1); + while (nextMonday.DayOfWeek != DayOfWeek.Monday) + nextMonday = nextMonday.AddDays(1); + + return (nextMonday, nextMonday.AddDays(4)); // Monday to Friday + } + + // Default to tomorrow + var defaultDate = currentDate.AddDays(1); + return (defaultDate, defaultDate); + } + + private string GenerateConversationalFallback(string context, object data) + { + return context.ToLowerInvariant() switch + { + "welcome" => "Hello! šŸ‘‹ I'm your AI-powered Interview Scheduling assistant. I can help you find available time slots and check calendar availability using natural language. What would you like me to help you with today?", + "no_slots" => "I couldn't find any available slots that match your criteria. Would you like me to check different time ranges or suggest alternative options?", + "weekend_adjusted" => "Since you asked for a weekend day, I've found available slots for the next business days instead.", + _ => "I'm here to help with your scheduling needs. How can I assist you today?" + }; + } + } +} \ No newline at end of file diff --git a/Services/NaturalLanguageDateProcessor.cs b/Services/NaturalLanguageDateProcessor.cs new file mode 100644 index 0000000..f96f803 --- /dev/null +++ b/Services/NaturalLanguageDateProcessor.cs @@ -0,0 +1,276 @@ +using System; +using System.Collections.Generic; +using System.Globalization; +using System.Text.Json; +using InterviewSchedulingBot.Services.Integration; +using Microsoft.Extensions.Logging; + +namespace InterviewBot.Services +{ + /// + /// Pure AI-driven date processor that understands natural language without hardcoded scenarios + /// Handles business days, weekends, and conversational date references through AI interpretation + /// + public class NaturalLanguageDateProcessor + { + private readonly ICleanOpenWebUIClient _aiClient; + private readonly ILogger _logger; + private readonly CultureInfo _englishCulture = new CultureInfo("en-US"); + + public NaturalLanguageDateProcessor( + ICleanOpenWebUIClient aiClient, + ILogger logger) + { + _aiClient = aiClient; + _logger = logger; + } + + /// + /// Process date references using pure AI semantic understanding + /// Automatically handles business days vs calendar days through AI interpretation + /// + public async Task<(DateTime startDate, DateTime endDate)> ProcessDateReferenceAsync( + string userRequest, + DateTime currentDate) + { + try + { + // Use AI to interpret the date reference with business context + var dateIntent = await ExtractDateIntentAsync(userRequest, currentDate); + + // Convert AI-extracted intent to actual dates + return await InterpretDateIntentAsync(dateIntent, currentDate); + } + catch (Exception ex) + { + _logger.LogError(ex, "Error processing date reference, falling back to next business day"); + return GetNextBusinessDay(currentDate); + } + } + + /// + /// Extract date intent using AI without hardcoded logic + /// + private async Task ExtractDateIntentAsync(string userRequest, DateTime currentDate) + { + var systemPrompt = $@"You are a business calendar assistant. Analyze the user's date request and extract the scheduling intent. + +CURRENT CONTEXT: +- Today is {currentDate:dddd, MMMM dd, yyyy} +- Current time: {currentDate:HH:mm} + +BUSINESS RULES: +- Business days are Monday-Friday, 9 AM to 5 PM +- When someone says 'tomorrow' and tomorrow is a weekend, they typically mean next business day +- 'Next week' usually means the upcoming Monday-Friday work week +- 'First X days' means exactly that many consecutive business days + +EXTRACT: +1. DateType: 'specific_day', 'relative_day', 'week_range', 'business_days' +2. TimeFrame: Description of when they want to meet +3. DayCount: Number of days if specified (e.g., 'first 3 days') +4. IncludeWeekends: true/false based on context +5. BusinessDayAdjustment: true if weekends should be shifted to business days + +USER REQUEST: {userRequest} + +Respond with ONLY a JSON object:"; + + try + { + var prompt = systemPrompt + "\n\nExample responses:\n" + + "{'DateType': 'relative_day', 'TimeFrame': 'tomorrow', 'DayCount': 1, 'IncludeWeekends': false, 'BusinessDayAdjustment': true}\n" + + "{'DateType': 'business_days', 'TimeFrame': 'first 3 days of next week', 'DayCount': 3, 'IncludeWeekends': false, 'BusinessDayAdjustment': true}"; + + // Use the existing parameter extraction but adapt for date intent + var fakeRequest = $"Extract date intent from: {userRequest}. Context: {prompt}"; + var response = await _aiClient.ExtractParametersAsync(fakeRequest); + + // For now, use simplified extraction and build DateIntent + return new DateIntent + { + DateType = DetermineDateType(userRequest), + TimeFrame = response.TimeFrame.ToLowerInvariant(), + DayCount = ExtractDayCount(userRequest), + IncludeWeekends = !ContainsBusinessDayIndicators(userRequest), + BusinessDayAdjustment = true // Always adjust to business days for better UX + }; + } + catch (Exception ex) + { + _logger.LogError(ex, "Error extracting date intent via AI"); + return CreateFallbackDateIntent(userRequest); + } + } + + /// + /// Interpret the AI-extracted date intent into actual DateTime values + /// + private async Task<(DateTime startDate, DateTime endDate)> InterpretDateIntentAsync( + DateIntent intent, + DateTime currentDate) + { + switch (intent.DateType) + { + case "relative_day": + return await HandleRelativeDayAsync(intent, currentDate); + + case "week_range": + return await HandleWeekRangeAsync(intent, currentDate); + + case "business_days": + return await HandleBusinessDaysAsync(intent, currentDate); + + default: + return GetNextBusinessDay(currentDate); + } + } + + private async Task<(DateTime startDate, DateTime endDate)> HandleRelativeDayAsync( + DateIntent intent, + DateTime currentDate) + { + if (intent.TimeFrame.Contains("tomorrow")) + { + var tomorrow = currentDate.AddDays(1).Date; + + // If tomorrow is weekend and business adjustment is enabled, use next business day + if (intent.BusinessDayAdjustment && IsWeekend(tomorrow)) + { + var nextBusinessDay = GetNextBusinessDay(currentDate); + return (nextBusinessDay.startDate, nextBusinessDay.endDate); + } + + return (tomorrow.AddHours(9), tomorrow.AddHours(17)); + } + + // Default to next business day + return GetNextBusinessDay(currentDate); + } + + private async Task<(DateTime startDate, DateTime endDate)> HandleWeekRangeAsync( + DateIntent intent, + DateTime currentDate) + { + if (intent.TimeFrame.Contains("next week")) + { + var nextMonday = GetNextMonday(currentDate); + var endDay = intent.DayCount.HasValue ? + nextMonday.AddDays(intent.DayCount.Value - 1) : + nextMonday.AddDays(4); // Default to Friday + + return (nextMonday.AddHours(9), endDay.AddHours(17)); + } + + return GetNextBusinessDay(currentDate); + } + + private async Task<(DateTime startDate, DateTime endDate)> HandleBusinessDaysAsync( + DateIntent intent, + DateTime currentDate) + { + if (intent.TimeFrame.Contains("first") && intent.DayCount.HasValue) + { + var startDay = intent.TimeFrame.Contains("next week") ? + GetNextMonday(currentDate) : + GetNextBusinessDay(currentDate).startDate.Date; + + var endDay = AddBusinessDays(startDay, intent.DayCount.Value - 1); + return (startDay.AddHours(9), endDay.AddHours(17)); + } + + return GetNextBusinessDay(currentDate); + } + + // Helper methods for business day calculations + private (DateTime startDate, DateTime endDate) GetNextBusinessDay(DateTime currentDate) + { + var nextDay = currentDate.AddDays(1).Date; + + // Skip weekends + while (IsWeekend(nextDay)) + { + nextDay = nextDay.AddDays(1); + } + + return (nextDay.AddHours(9), nextDay.AddHours(17)); + } + + private DateTime GetNextMonday(DateTime currentDate) + { + int daysUntilMonday = ((int)DayOfWeek.Monday - (int)currentDate.DayOfWeek + 7) % 7; + if (daysUntilMonday == 0) daysUntilMonday = 7; + return currentDate.AddDays(daysUntilMonday).Date; + } + + private DateTime AddBusinessDays(DateTime startDate, int businessDays) + { + var result = startDate; + for (int i = 0; i < businessDays; i++) + { + result = result.AddDays(1); + while (IsWeekend(result)) + { + result = result.AddDays(1); + } + } + return result; + } + + private bool IsWeekend(DateTime date) => + date.DayOfWeek == DayOfWeek.Saturday || date.DayOfWeek == DayOfWeek.Sunday; + + // Simplified extraction methods (eventually these would be AI-driven too) + private string DetermineDateType(string request) + { + var lower = request.ToLowerInvariant(); + if (lower.Contains("tomorrow")) return "relative_day"; + if (lower.Contains("next week") && lower.Contains("first")) return "business_days"; + if (lower.Contains("next week")) return "week_range"; + return "relative_day"; + } + + private int? ExtractDayCount(string request) + { + var lower = request.ToLowerInvariant(); + if (lower.Contains("first")) + { + if (lower.Contains("2") || lower.Contains("two")) return 2; + if (lower.Contains("3") || lower.Contains("three")) return 3; + if (lower.Contains("4") || lower.Contains("four")) return 4; + if (lower.Contains("5") || lower.Contains("five")) return 5; + } + return null; + } + + private bool ContainsBusinessDayIndicators(string request) + { + var lower = request.ToLowerInvariant(); + return lower.Contains("business") || lower.Contains("work") || lower.Contains("weekday"); + } + + private DateIntent CreateFallbackDateIntent(string request) + { + return new DateIntent + { + DateType = "relative_day", + TimeFrame = "next business day", + DayCount = 1, + IncludeWeekends = false, + BusinessDayAdjustment = true + }; + } + } + + /// + /// Represents the AI-extracted intent from a date request + /// + public class DateIntent + { + public string DateType { get; set; } = ""; + public string TimeFrame { get; set; } = ""; + public int? DayCount { get; set; } + public bool IncludeWeekends { get; set; } + public bool BusinessDayAdjustment { get; set; } + } +} \ No newline at end of file diff --git a/Services/TimeSlotResponseFormatter.cs b/Services/TimeSlotResponseFormatter.cs new file mode 100644 index 0000000..b0affaf --- /dev/null +++ b/Services/TimeSlotResponseFormatter.cs @@ -0,0 +1,103 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using InterviewBot.Models; +using InterviewBot.Services; + +namespace InterviewBot.Services +{ + public class TimeSlotResponseFormatter + { + public string FormatTimeSlotResponse( + List slots, + DateTime startDate, + DateTime endDate, + int durationMinutes, + string originalRequest) // Add this parameter + { + var sb = new StringBuilder(); + + // Handle no slots found + if (!slots.Any()) + { + return $"I couldn't find any suitable {durationMinutes}-minute slots between " + + $"{DateFormattingService.FormatDateWithDay(startDate)} and " + + $"{DateFormattingService.FormatDateWithDay(endDate)}. " + + "Would you like me to check different dates or a different duration?"; + } + + // Make opening more conversational while keeping date format + bool isSingleDay = startDate.Date == endDate.Date; + + if (isSingleDay) + { + sb.AppendLine($"I've found the following {durationMinutes}-minute time slots for {DateFormattingService.FormatDateWithDay(startDate)}:"); + } + else + { + // Check if this is "first X days" scenario + bool isLimitedDays = (endDate.Date - startDate.Date).Days < 4 && originalRequest.ToLower().Contains("first"); + + if (isLimitedDays) + { + int dayCount = (endDate.Date - startDate.Date).Days + 1; + sb.AppendLine($"I've found the following {durationMinutes}-minute time slots for the first {dayCount} days of next week [{startDate:dd.MM.yyyy} - {endDate:dd.MM.yyyy}]:"); + } + else + { + sb.AppendLine($"I've found the following {durationMinutes}-minute time slots for next week [{startDate:dd.MM.yyyy} - {endDate:dd.MM.yyyy}]:"); + } + } + + sb.AppendLine(); + + // Group slots by day + var slotsByDay = slots + .GroupBy(s => s.StartTime.Date) + .OrderBy(g => g.Key); + + // Only show days that fall within the requested range + foreach (var dayGroup in slotsByDay) + { + // Only include days within the requested range + if (dayGroup.Key < startDate.Date || dayGroup.Key > endDate.Date) + continue; + + sb.AppendLine($"{DateFormattingService.FormatDateWithDay(dayGroup.Key)}"); + sb.AppendLine(); + + // Add slots for this day + foreach (var slot in dayGroup.OrderBy(s => s.StartTime)) + { + // Show time range + participant info + recommendation + string timeRange = $"{slot.StartTime:HH:mm} - {slot.EndTime:HH:mm}"; + + // Get specific availability description (showing who is unavailable) + string availabilityDesc = slot.GetParticipantAvailabilityDescription(); + + if (slot.IsRecommended) + sb.AppendLine($"{timeRange} {availabilityDesc} ā­ RECOMMENDED"); + else + sb.AppendLine($"{timeRange} {availabilityDesc}"); + } + + sb.AppendLine(); + } + + sb.AppendLine("Please let me know which time slot works best for you."); + + return sb.ToString(); + } + + // Keep original method for backward compatibility + public string FormatResponse( + List slots, + int durationMinutes, + DateTime startDate, + DateTime endDate) + { + return FormatTimeSlotResponse(slots, startDate, endDate, durationMinutes, ""); + } + } +} \ No newline at end of file diff --git a/Tests/Unit/DateFormattingServiceTests.cs b/Tests/Unit/DateFormattingServiceTests.cs new file mode 100644 index 0000000..4e23d56 --- /dev/null +++ b/Tests/Unit/DateFormattingServiceTests.cs @@ -0,0 +1,133 @@ +using Xunit; +using InterviewBot.Services; +using System; + +namespace InterviewBot.Tests.Unit +{ + public class DateFormattingServiceTests + { + [Fact] + public void FormatDateWithDay_ValidDate_ReturnsCorrectFormat() + { + // Arrange + var date = new DateTime(2025, 8, 4); // Monday, August 4, 2025 + + // Act + var result = DateFormattingService.FormatDateWithDay(date); + + // Assert + Assert.Equal("Monday [04.08.2025]", result); + } + + [Fact] + public void FormatTimeRange_ValidTimes_ReturnsCorrectFormat() + { + // Arrange + var start = new DateTime(2025, 1, 6, 9, 30, 0); + var end = new DateTime(2025, 1, 6, 10, 30, 0); + + // Act + var result = DateFormattingService.FormatTimeRange(start, end); + + // Assert + Assert.Equal("09:30 - 10:30", result); + } + + [Fact] + public void FormatDateRange_ValidDates_ReturnsCorrectFormat() + { + // Arrange + var start = new DateTime(2025, 1, 6); + var end = new DateTime(2025, 1, 10); + + // Act + var result = DateFormattingService.FormatDateRange(start, end); + + // Assert + Assert.Equal("[06.01.2025 - 10.01.2025]", result); + } + + [Fact] + public void GetNextBusinessDay_Friday_ReturnsMonday() + { + // Arrange + var friday = new DateTime(2025, 1, 3); // Friday + + // Act + var result = DateFormattingService.GetNextBusinessDay(friday); + + // Assert + Assert.Equal(DayOfWeek.Monday, result.DayOfWeek); + Assert.Equal(new DateTime(2025, 1, 6), result.Date); // Monday + } + + [Fact] + public void GetNextBusinessDay_Saturday_ReturnsMonday() + { + // Arrange + var saturday = new DateTime(2025, 1, 4); // Saturday + + // Act + var result = DateFormattingService.GetNextBusinessDay(saturday); + + // Assert + Assert.Equal(DayOfWeek.Monday, result.DayOfWeek); + Assert.Equal(new DateTime(2025, 1, 6), result.Date); // Monday + } + + [Fact] + public void GetNextBusinessDay_Tuesday_ReturnsWednesday() + { + // Arrange + var tuesday = new DateTime(2025, 1, 7); // Tuesday + + // Act + var result = DateFormattingService.GetNextBusinessDay(tuesday); + + // Assert + Assert.Equal(DayOfWeek.Wednesday, result.DayOfWeek); + Assert.Equal(new DateTime(2025, 1, 8), result.Date); // Wednesday + } + + [Fact] + public void GetRelativeDateDescription_Today_ReturnsToday() + { + // Arrange + var today = DateTime.Now.Date; + + // Act + var result = DateFormattingService.GetRelativeDateDescription(today, today); + + // Assert + Assert.Equal("today", result); + } + + [Fact] + public void GetRelativeDateDescription_Tomorrow_ReturnsTomorrow() + { + // Arrange + var today = DateTime.Now.Date; + var tomorrow = today.AddDays(1); + + // Act + var result = DateFormattingService.GetRelativeDateDescription(tomorrow, today); + + // Assert + Assert.Equal("tomorrow", result); + } + + [Fact] + public void GetRelativeDateDescription_ThreeDaysAway_ReturnsRelativeDescription() + { + // Arrange + var today = new DateTime(2025, 1, 6); // Monday + var target = new DateTime(2025, 1, 9); // Thursday + + // Act + var result = DateFormattingService.GetRelativeDateDescription(target, today); + + // Assert + Assert.Equal("in 3 days on Thursday [09.01.2025]", result); + } + } +} \ No newline at end of file diff --git a/Tests/Unit/DeterministicSlotRecommendationServiceTests.cs b/Tests/Unit/DeterministicSlotRecommendationServiceTests.cs new file mode 100644 index 0000000..04c3662 --- /dev/null +++ b/Tests/Unit/DeterministicSlotRecommendationServiceTests.cs @@ -0,0 +1,99 @@ +using Xunit; +using InterviewBot.Services; +using InterviewBot.Models; +using System; +using System.Collections.Generic; +using System.Linq; + +namespace InterviewBot.Tests.Unit +{ + public class DeterministicSlotRecommendationServiceTests + { + [Fact] + public void GenerateConsistentTimeSlots_SameInputs_ReturnsSameResults() + { + // Arrange + var dateInterpreter = new DateRangeInterpreter(); + var service = new DeterministicSlotRecommendationService(dateInterpreter); + var startDate = new DateTime(2025, 1, 6, 9, 0, 0); // Monday + var endDate = new DateTime(2025, 1, 6, 17, 0, 0); + var duration = 60; + var participants = new List { "jane.smith@company.com", "alex.wilson@company.com" }; + + // Act + var slots1 = service.GenerateConsistentTimeSlots(startDate, endDate, duration, participants); + var slots2 = service.GenerateConsistentTimeSlots(startDate, endDate, duration, participants); + var slots3 = service.GenerateConsistentTimeSlots(startDate, endDate, duration, participants); + + // Assert + Assert.NotEmpty(slots1); + Assert.Equal(slots1.Count, slots2.Count); + Assert.Equal(slots1.Count, slots3.Count); + + // Check that the slots are identical + for (int i = 0; i < slots1.Count; i++) + { + Assert.Equal(slots1[i].StartTime, slots2[i].StartTime); + Assert.Equal(slots1[i].EndTime, slots2[i].EndTime); + Assert.Equal(slots1[i].Score, slots2[i].Score); + Assert.Equal(slots1[i].Reason, slots2[i].Reason); + Assert.Equal(slots1[i].IsRecommended, slots2[i].IsRecommended); + + Assert.Equal(slots1[i].StartTime, slots3[i].StartTime); + Assert.Equal(slots1[i].EndTime, slots3[i].EndTime); + Assert.Equal(slots1[i].Score, slots3[i].Score); + Assert.Equal(slots1[i].Reason, slots3[i].Reason); + Assert.Equal(slots1[i].IsRecommended, slots3[i].IsRecommended); + } + } + + [Fact] + public void GenerateConsistentTimeSlots_QuarterHourAlignment_AllSlotsAligned() + { + // Arrange + var dateInterpreter = new DateRangeInterpreter(); + var service = new DeterministicSlotRecommendationService(dateInterpreter); + var startDate = new DateTime(2025, 1, 6, 9, 0, 0); + var endDate = new DateTime(2025, 1, 6, 17, 0, 0); + var duration = 60; + var participants = new List { "test@example.com" }; + + // Act + var slots = service.GenerateConsistentTimeSlots(startDate, endDate, duration, participants); + + // Assert + foreach (var slot in slots) + { + Assert.True(slot.StartTime.Minute % 15 == 0, + $"Slot start time {slot.StartTime} is not aligned to 15-minute intervals"); + } + } + + [Fact] + public void GenerateConsistentTimeSlots_HasRecommendedSlot_OnlyOneRecommended() + { + // Arrange + var dateInterpreter = new DateRangeInterpreter(); + var service = new DeterministicSlotRecommendationService(dateInterpreter); + var startDate = new DateTime(2025, 1, 6, 9, 0, 0); + var endDate = new DateTime(2025, 1, 6, 17, 0, 0); + var duration = 60; + var participants = new List { "test@example.com" }; + + // Act + var slots = service.GenerateConsistentTimeSlots(startDate, endDate, duration, participants); + + // Assert + var recommendedSlots = slots.Where(s => s.IsRecommended).ToList(); + Assert.True(recommendedSlots.Count <= 1, "More than one slot is marked as recommended"); + + if (recommendedSlots.Any()) + { + Assert.Contains("ā­ RECOMMENDED", recommendedSlots[0].Reason); + + // The recommended slot should be the first one (highest score) + Assert.Equal(slots[0].StartTime, recommendedSlots[0].StartTime); + } + } + } +} \ No newline at end of file diff --git a/appsettings.json b/appsettings.json index 44ce4c3..000f1c1 100644 --- a/appsettings.json +++ b/appsettings.json @@ -90,6 +90,7 @@ "ShowDebugInfo": true, "MaxTokens": 1000, "Temperature": 0.7, - "Timeout": 30000 + "Timeout": 30000, + "UseMockData": true } }