361 lines
13 KiB
C#
361 lines
13 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using Microsoft.Graph.Models;
|
|
using MimeKit;
|
|
using Wino.Core.Domain.Entities.Calendar;
|
|
using Wino.Core.Domain.Entities.Mail;
|
|
using Wino.Core.Domain.Entities.Shared;
|
|
using Wino.Core.Domain.Enums;
|
|
using Wino.Core.Misc;
|
|
|
|
namespace Wino.Core.Extensions;
|
|
|
|
public static class OutlookIntegratorExtensions
|
|
{
|
|
public static MailItemFolder GetLocalFolder(this MailFolder nativeFolder, Guid accountId)
|
|
{
|
|
return new MailItemFolder()
|
|
{
|
|
Id = Guid.NewGuid(),
|
|
FolderName = nativeFolder.DisplayName,
|
|
RemoteFolderId = nativeFolder.Id,
|
|
ParentRemoteFolderId = nativeFolder.ParentFolderId,
|
|
IsSynchronizationEnabled = true,
|
|
MailAccountId = accountId,
|
|
IsHidden = nativeFolder.IsHidden.GetValueOrDefault()
|
|
};
|
|
}
|
|
|
|
public static bool GetIsDraft(this Message message)
|
|
=> message != null && message.IsDraft.GetValueOrDefault();
|
|
|
|
public static bool GetIsRead(this Message message)
|
|
=> message != null && message.IsRead.GetValueOrDefault();
|
|
|
|
public static bool GetIsFocused(this Message message)
|
|
=> message?.InferenceClassification != null && message.InferenceClassification.Value == InferenceClassificationType.Focused;
|
|
|
|
public static bool GetIsFlagged(this Message message)
|
|
=> message?.Flag?.FlagStatus != null && message.Flag.FlagStatus == FollowupFlagStatus.Flagged;
|
|
|
|
public static MailCopy AsMailCopy(this Message outlookMessage)
|
|
{
|
|
bool isDraft = GetIsDraft(outlookMessage);
|
|
|
|
var mailCopy = new MailCopy()
|
|
{
|
|
MessageId = outlookMessage.InternetMessageId,
|
|
IsFlagged = GetIsFlagged(outlookMessage),
|
|
IsFocused = GetIsFocused(outlookMessage),
|
|
Importance = !outlookMessage.Importance.HasValue ? MailImportance.Normal : (MailImportance)outlookMessage.Importance.Value,
|
|
IsRead = GetIsRead(outlookMessage),
|
|
IsDraft = isDraft,
|
|
CreationDate = outlookMessage.ReceivedDateTime.GetValueOrDefault().DateTime,
|
|
HasAttachments = outlookMessage.HasAttachments.GetValueOrDefault(),
|
|
PreviewText = outlookMessage.BodyPreview,
|
|
Id = outlookMessage.Id,
|
|
ThreadId = outlookMessage.ConversationId,
|
|
FromName = outlookMessage.From?.EmailAddress?.Name,
|
|
FromAddress = outlookMessage.From?.EmailAddress?.Address,
|
|
Subject = outlookMessage.Subject,
|
|
FileId = Guid.NewGuid()
|
|
};
|
|
|
|
if (mailCopy.IsDraft)
|
|
mailCopy.DraftId = mailCopy.ThreadId;
|
|
|
|
return mailCopy;
|
|
}
|
|
|
|
public static Message AsOutlookMessage(this MimeMessage mime, bool includeInternetHeaders)
|
|
{
|
|
var fromAddress = GetRecipients(mime.From).ElementAt(0);
|
|
var toAddresses = GetRecipients(mime.To).ToList();
|
|
var ccAddresses = GetRecipients(mime.Cc).ToList();
|
|
var bccAddresses = GetRecipients(mime.Bcc).ToList();
|
|
var replyToAddresses = GetRecipients(mime.ReplyTo).ToList();
|
|
|
|
var message = new Message()
|
|
{
|
|
Subject = mime.Subject,
|
|
Importance = GetImportance(mime.Importance),
|
|
Body = new ItemBody() { ContentType = BodyType.Html, Content = mime.HtmlBody },
|
|
IsDraft = false,
|
|
IsRead = true, // Sent messages are always read.
|
|
ToRecipients = toAddresses,
|
|
CcRecipients = ccAddresses,
|
|
BccRecipients = bccAddresses,
|
|
From = fromAddress,
|
|
InternetMessageId = GetProperId(mime.MessageId),
|
|
ReplyTo = replyToAddresses,
|
|
Attachments = []
|
|
};
|
|
|
|
// Headers are only included when creating the draft.
|
|
// When sending, they are not included. Graph will throw an error.
|
|
|
|
if (includeInternetHeaders)
|
|
{
|
|
message.InternetMessageHeaders = GetHeaderList(mime);
|
|
}
|
|
|
|
|
|
return message;
|
|
}
|
|
|
|
public static AccountCalendar AsCalendar(this Calendar outlookCalendar, MailAccount assignedAccount)
|
|
{
|
|
var calendar = new AccountCalendar()
|
|
{
|
|
AccountId = assignedAccount.Id,
|
|
Id = Guid.NewGuid(),
|
|
RemoteCalendarId = outlookCalendar.Id,
|
|
IsPrimary = outlookCalendar.IsDefaultCalendar.GetValueOrDefault(),
|
|
Name = outlookCalendar.Name,
|
|
IsExtended = true,
|
|
};
|
|
|
|
// Colors:
|
|
// Bg must be present. Generate flat one if doesn't exists.
|
|
// Text doesnt exists for Outlook.
|
|
|
|
calendar.BackgroundColorHex = string.IsNullOrEmpty(outlookCalendar.HexColor) ? ColorHelpers.GenerateFlatColorHex() : outlookCalendar.HexColor;
|
|
calendar.TextColorHex = "#000000";
|
|
|
|
return calendar;
|
|
}
|
|
|
|
private static string GetRfc5545DayOfWeek(DayOfWeekObject dayOfWeek)
|
|
{
|
|
return dayOfWeek switch
|
|
{
|
|
DayOfWeekObject.Monday => "MO",
|
|
DayOfWeekObject.Tuesday => "TU",
|
|
DayOfWeekObject.Wednesday => "WE",
|
|
DayOfWeekObject.Thursday => "TH",
|
|
DayOfWeekObject.Friday => "FR",
|
|
DayOfWeekObject.Saturday => "SA",
|
|
DayOfWeekObject.Sunday => "SU",
|
|
_ => throw new ArgumentOutOfRangeException(nameof(dayOfWeek), dayOfWeek, null)
|
|
};
|
|
}
|
|
|
|
public static string ToRfc5545RecurrenceString(this PatternedRecurrence recurrence)
|
|
{
|
|
if (recurrence == null || recurrence.Pattern == null)
|
|
throw new ArgumentNullException(nameof(recurrence), "PatternedRecurrence or its Pattern cannot be null.");
|
|
|
|
var ruleBuilder = new StringBuilder("RRULE:");
|
|
var pattern = recurrence.Pattern;
|
|
|
|
// Frequency
|
|
switch (pattern.Type)
|
|
{
|
|
case RecurrencePatternType.Daily:
|
|
ruleBuilder.Append("FREQ=DAILY;");
|
|
break;
|
|
case RecurrencePatternType.Weekly:
|
|
ruleBuilder.Append("FREQ=WEEKLY;");
|
|
break;
|
|
case RecurrencePatternType.AbsoluteMonthly:
|
|
ruleBuilder.Append("FREQ=MONTHLY;");
|
|
break;
|
|
case RecurrencePatternType.AbsoluteYearly:
|
|
ruleBuilder.Append("FREQ=YEARLY;");
|
|
break;
|
|
case RecurrencePatternType.RelativeMonthly:
|
|
ruleBuilder.Append("FREQ=MONTHLY;");
|
|
break;
|
|
case RecurrencePatternType.RelativeYearly:
|
|
ruleBuilder.Append("FREQ=YEARLY;");
|
|
break;
|
|
default:
|
|
throw new NotSupportedException($"Unsupported recurrence pattern type: {pattern.Type}");
|
|
}
|
|
|
|
// Interval
|
|
if (pattern.Interval > 0)
|
|
ruleBuilder.Append($"INTERVAL={pattern.Interval};");
|
|
|
|
// Days of Week
|
|
if (pattern.DaysOfWeek?.Any() == true)
|
|
{
|
|
var days = string.Join(",", pattern.DaysOfWeek.Select(day => day.ToString().ToUpperInvariant().Substring(0, 2)));
|
|
ruleBuilder.Append($"BYDAY={days};");
|
|
}
|
|
|
|
// Day of Month (BYMONTHDAY)
|
|
if (pattern.Type == RecurrencePatternType.AbsoluteMonthly || pattern.Type == RecurrencePatternType.AbsoluteYearly)
|
|
{
|
|
if (pattern.DayOfMonth <= 0)
|
|
throw new ArgumentException("DayOfMonth must be greater than 0 for absoluteMonthly or absoluteYearly patterns.");
|
|
|
|
ruleBuilder.Append($"BYMONTHDAY={pattern.DayOfMonth};");
|
|
}
|
|
|
|
// Month (BYMONTH)
|
|
if (pattern.Type == RecurrencePatternType.AbsoluteYearly || pattern.Type == RecurrencePatternType.RelativeYearly)
|
|
{
|
|
if (pattern.Month <= 0)
|
|
throw new ArgumentException("Month must be greater than 0 for absoluteYearly or relativeYearly patterns.");
|
|
|
|
ruleBuilder.Append($"BYMONTH={pattern.Month};");
|
|
}
|
|
|
|
// Count or Until
|
|
if (recurrence.Range != null)
|
|
{
|
|
if (recurrence.Range.Type == RecurrenceRangeType.EndDate && recurrence.Range.EndDate != null)
|
|
{
|
|
ruleBuilder.Append($"UNTIL={recurrence.Range.EndDate.Value:yyyyMMddTHHmmssZ};");
|
|
}
|
|
else if (recurrence.Range.Type == RecurrenceRangeType.Numbered && recurrence.Range.NumberOfOccurrences.HasValue)
|
|
{
|
|
ruleBuilder.Append($"COUNT={recurrence.Range.NumberOfOccurrences.Value};");
|
|
}
|
|
}
|
|
|
|
// Remove trailing semicolon
|
|
return ruleBuilder.ToString().TrimEnd(';');
|
|
}
|
|
|
|
public static DateTimeOffset GetDateTimeOffsetFromDateTimeTimeZone(DateTimeTimeZone dateTimeTimeZone)
|
|
{
|
|
if (dateTimeTimeZone == null || string.IsNullOrEmpty(dateTimeTimeZone.DateTime) || string.IsNullOrEmpty(dateTimeTimeZone.TimeZone))
|
|
{
|
|
throw new ArgumentException("DateTimeTimeZone is null or empty.");
|
|
}
|
|
|
|
try
|
|
{
|
|
// Parse the DateTime string
|
|
if (DateTime.TryParse(dateTimeTimeZone.DateTime, out DateTime parsedDateTime))
|
|
{
|
|
// Get TimeZoneInfo to get the offset
|
|
TimeZoneInfo timeZoneInfo = TimeZoneInfo.FindSystemTimeZoneById(dateTimeTimeZone.TimeZone);
|
|
TimeSpan offset = timeZoneInfo.GetUtcOffset(parsedDateTime);
|
|
return new DateTimeOffset(parsedDateTime, offset);
|
|
}
|
|
else
|
|
throw new ArgumentException("DateTime string is not in a valid format.");
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw;
|
|
}
|
|
}
|
|
|
|
private static AttendeeStatus GetAttendeeStatus(ResponseType? responseType)
|
|
{
|
|
return responseType switch
|
|
{
|
|
ResponseType.None => AttendeeStatus.NeedsAction,
|
|
ResponseType.NotResponded => AttendeeStatus.NeedsAction,
|
|
ResponseType.Organizer => AttendeeStatus.Accepted,
|
|
ResponseType.TentativelyAccepted => AttendeeStatus.Tentative,
|
|
ResponseType.Accepted => AttendeeStatus.Accepted,
|
|
ResponseType.Declined => AttendeeStatus.Declined,
|
|
_ => AttendeeStatus.NeedsAction
|
|
};
|
|
}
|
|
|
|
public static CalendarEventAttendee CreateAttendee(this Attendee attendee, Guid calendarItemId)
|
|
{
|
|
bool isOrganizer = attendee?.Status?.Response == ResponseType.Organizer;
|
|
|
|
var eventAttendee = new CalendarEventAttendee()
|
|
{
|
|
CalendarItemId = calendarItemId,
|
|
Id = Guid.NewGuid(),
|
|
Email = attendee.EmailAddress?.Address,
|
|
Name = attendee.EmailAddress?.Name,
|
|
AttendenceStatus = GetAttendeeStatus(attendee.Status.Response),
|
|
IsOrganizer = isOrganizer,
|
|
IsOptionalAttendee = attendee.Type == AttendeeType.Optional,
|
|
};
|
|
|
|
return eventAttendee;
|
|
}
|
|
|
|
#region Mime to Outlook Message Helpers
|
|
|
|
private static IEnumerable<Recipient> GetRecipients(this InternetAddressList internetAddresses)
|
|
{
|
|
foreach (var address in internetAddresses)
|
|
{
|
|
if (address is MailboxAddress mailboxAddress)
|
|
yield return new Recipient() { EmailAddress = new EmailAddress() { Address = mailboxAddress.Address, Name = mailboxAddress.Name } };
|
|
else if (address is GroupAddress groupAddress)
|
|
{
|
|
// TODO: Group addresses are not directly supported.
|
|
// It'll be individually added.
|
|
|
|
foreach (var mailbox in groupAddress.Members)
|
|
if (mailbox is MailboxAddress groupMemberMailAddress)
|
|
yield return new Recipient() { EmailAddress = new EmailAddress() { Address = groupMemberMailAddress.Address, Name = groupMemberMailAddress.Name } };
|
|
}
|
|
}
|
|
}
|
|
|
|
private static Importance? GetImportance(MessageImportance importance)
|
|
{
|
|
return importance switch
|
|
{
|
|
MessageImportance.Low => Importance.Low,
|
|
MessageImportance.Normal => Importance.Normal,
|
|
MessageImportance.High => Importance.High,
|
|
_ => null
|
|
};
|
|
}
|
|
|
|
private static List<InternetMessageHeader> GetHeaderList(this MimeMessage mime)
|
|
{
|
|
// Graph API only allows max of 5 headers.
|
|
// Here we'll try to ignore some headers that are not neccessary.
|
|
// Outlook API will generate them automatically.
|
|
|
|
// Some headers also require to start with X- or x-.
|
|
|
|
string[] headersToIgnore = ["Date", "To", "Cc", "Bcc", "MIME-Version", "From", "Subject", "Message-Id"];
|
|
string[] headersToModify = ["In-Reply-To", "Reply-To", "References", "Thread-Topic"];
|
|
|
|
var headers = new List<InternetMessageHeader>();
|
|
|
|
int includedHeaderCount = 0;
|
|
|
|
foreach (var header in mime.Headers)
|
|
{
|
|
if (!headersToIgnore.Contains(header.Field))
|
|
{
|
|
var headerName = headersToModify.Contains(header.Field) ? $"X-{header.Field}" : header.Field;
|
|
|
|
// No header value should exceed 995 characters.
|
|
var headerValue = header.Value.Length >= 995 ? header.Value.Substring(0, 995) : header.Value;
|
|
|
|
headers.Add(new InternetMessageHeader() { Name = headerName, Value = headerValue });
|
|
includedHeaderCount++;
|
|
}
|
|
|
|
if (includedHeaderCount >= 5) break;
|
|
}
|
|
|
|
return headers;
|
|
}
|
|
|
|
private static string GetProperId(string id)
|
|
{
|
|
// Outlook requires some identifiers to start with "X-" or "x-".
|
|
if (string.IsNullOrEmpty(id)) return string.Empty;
|
|
|
|
if (!id.StartsWith("x-") || !id.StartsWith("X-"))
|
|
return $"X-{id}";
|
|
|
|
return id;
|
|
}
|
|
|
|
|
|
#endregion
|
|
}
|