Initial commit.

Wino.Core/Extensions/FolderTreeExtensions.cs

@@ -0,0 +1,54 @@
+using System.Linq;
+using Wino.Core.Domain.Interfaces;
+using Wino.Core.Domain.Models.Folders;
+using Wino.Core.MenuItems;
+
+namespace Wino.Core.Extensions
+{
+    public static class FolderTreeExtensions
+    {
+        public static AccountMenuItem GetAccountMenuTree(this AccountFolderTree accountTree, IMenuItem parentMenuItem = null)
+        {
+            var accountMenuItem = new AccountMenuItem(accountTree.Account, parentMenuItem);
+
+            foreach (var structure in accountTree.Folders)
+            {
+                var tree = GetMenuItemByFolderRecursive(structure, accountMenuItem, null);
+
+                accountMenuItem.SubMenuItems.Add(tree);
+            }
+
+
+            // Create flat folder hierarchy for ease of access.
+            accountMenuItem.FlattenedFolderHierarchy = ListExtensions
+                .FlattenBy(accountMenuItem.SubMenuItems, a => a.SubMenuItems)
+                .Where(a => a is FolderMenuItem)
+                .Cast<FolderMenuItem>()
+                .ToList();
+
+            return accountMenuItem;
+        }
+
+        private static MenuItemBase<IMailItemFolder, FolderMenuItem> GetMenuItemByFolderRecursive(IMailItemFolder structure, AccountMenuItem parentAccountMenuItem, IMenuItem parentFolderItem)
+        {
+            MenuItemBase<IMailItemFolder, FolderMenuItem> parentMenuItem = new FolderMenuItem(structure, parentAccountMenuItem.Parameter, parentAccountMenuItem);
+
+            var childStructures = structure.ChildFolders;
+
+            foreach (var childFolder in childStructures)
+            {
+                if (childFolder == null) continue;
+
+                // Folder menu item.
+                var subChildrenFolderTree = GetMenuItemByFolderRecursive(childFolder, parentAccountMenuItem, parentMenuItem);
+
+                if (subChildrenFolderTree is FolderMenuItem folderItem)
+                {
+                    parentMenuItem.SubMenuItems.Add(folderItem);
+                }
+            }
+
+            return parentMenuItem;
+        }
+    }
+}

Wino.Core/Extensions/GoogleIntegratorExtensions.cs

@@ -0,0 +1,162 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Web;
+using Google.Apis.Gmail.v1.Data;
+using MimeKit;
+using Wino.Core.Domain.Entities;
+using Wino.Core.Domain.Enums;
+
+namespace Wino.Core.Extensions
+{
+    public static class GoogleIntegratorExtensions
+    {
+        public const string INBOX_LABEL_ID = "INBOX";
+        public const string UNREAD_LABEL_ID = "UNREAD";
+        public const string IMPORTANT_LABEL_ID = "IMPORTANT";
+        public const string STARRED_LABEL_ID = "STARRED";
+        public const string DRAFT_LABEL_ID = "DRAFT";
+        public const string SENT_LABEL_ID = "SENT";
+
+        private const string SYSTEM_FOLDER_IDENTIFIER = "system";
+        private const string FOLDER_HIDE_IDENTIFIER = "labelHide";
+
+        private static Dictionary<string, SpecialFolderType> KnownFolderDictioanry = new Dictionary<string, SpecialFolderType>()
+        {
+            { INBOX_LABEL_ID, SpecialFolderType.Inbox },
+            { "CHAT", SpecialFolderType.Chat },
+            { IMPORTANT_LABEL_ID, SpecialFolderType.Important },
+            { "TRASH", SpecialFolderType.Deleted },
+            { DRAFT_LABEL_ID, SpecialFolderType.Draft },
+            { SENT_LABEL_ID, SpecialFolderType.Sent },
+            { "SPAM", SpecialFolderType.Junk },
+            { STARRED_LABEL_ID, SpecialFolderType.Starred },
+            { UNREAD_LABEL_ID, SpecialFolderType.Unread },
+            { "FORUMS", SpecialFolderType.Forums },
+            { "UPDATES", SpecialFolderType.Updates },
+            { "PROMOTIONS", SpecialFolderType.Promotions },
+            { "SOCIAL", SpecialFolderType.Social},
+            { "PERSONAL", SpecialFolderType.Personal},
+        };
+
+        public static MailItemFolder GetLocalFolder(this Label label, Guid accountId)
+        {
+            var unchangedFolderName = label.Name;
+
+            if (label.Name.StartsWith("CATEGORY_"))
+                label.Name = label.Name.Replace("CATEGORY_", "");
+
+            bool isSpecialFolder = KnownFolderDictioanry.ContainsKey(label.Name);
+            bool isAllCapital = label.Name.All(a => char.IsUpper(a));
+
+            var specialFolderType = isSpecialFolder ? KnownFolderDictioanry[label.Name] : SpecialFolderType.Other;
+
+            return new MailItemFolder()
+            {
+                TextColorHex = label.Color?.TextColor,
+                BackgroundColorHex = label.Color?.BackgroundColor,
+                FolderName = isAllCapital ? char.ToUpper(label.Name[0]) + label.Name.Substring(1).ToLower() : label.Name, // Capitilize only first letter.
+                RemoteFolderId = label.Id,
+                Id = Guid.NewGuid(),
+                MailAccountId = accountId,
+                IsSynchronizationEnabled = true,
+                SpecialFolderType = specialFolderType,
+                IsSystemFolder = label.Type == SYSTEM_FOLDER_IDENTIFIER,
+                IsSticky = isSpecialFolder && specialFolderType != SpecialFolderType.Category && !unchangedFolderName.StartsWith("CATEGORY"),
+                IsHidden = label.LabelListVisibility == FOLDER_HIDE_IDENTIFIER,
+
+                // By default, all special folders update unread count in the UI except Trash.
+                ShowUnreadCount = specialFolderType != SpecialFolderType.Deleted || specialFolderType != SpecialFolderType.Other
+            };
+        }
+
+        public static bool GetIsDraft(this Message message)
+            => message?.LabelIds?.Any(a => a == DRAFT_LABEL_ID) ?? false;
+
+        public static bool GetIsUnread(this Message message)
+            => message?.LabelIds?.Any(a => a == UNREAD_LABEL_ID) ?? false;
+
+        public static bool GetIsFocused(this Message message)
+            => message?.LabelIds?.Any(a => a == IMPORTANT_LABEL_ID) ?? false;
+
+        public static bool GetIsFlagged(this Message message)
+            => message?.LabelIds?.Any(a => a == STARRED_LABEL_ID) ?? false;
+
+        /// <summary>
+        /// Returns MailCopy out of native Gmail message and converted MimeMessage of that native messaage.
+        /// </summary>
+        /// <param name="gmailMessage">Gmail Message</param>
+        /// <param name="mimeMessage">MimeMessage representation of that native message.</param>
+        /// <returns>MailCopy object that is ready to be inserted to database.</returns>
+        public static MailCopy AsMailCopy(this Message gmailMessage, MimeMessage mimeMessage)
+        {
+            bool isUnread = gmailMessage.GetIsUnread();
+            bool isFocused = gmailMessage.GetIsFocused();
+            bool isFlagged = gmailMessage.GetIsFlagged();
+            bool isDraft = gmailMessage.GetIsDraft();
+
+            return new MailCopy()
+            {
+                CreationDate = mimeMessage.Date.UtcDateTime,
+                Subject = HttpUtility.HtmlDecode(mimeMessage.Subject),
+                FromName = MailkitClientExtensions.GetActualSenderName(mimeMessage),
+                FromAddress = MailkitClientExtensions.GetActualSenderAddress(mimeMessage),
+                PreviewText = HttpUtility.HtmlDecode(gmailMessage.Snippet),
+                ThreadId = gmailMessage.ThreadId,
+                Importance = (MailImportance)mimeMessage.Importance,
+                Id = gmailMessage.Id,
+                IsDraft = isDraft,
+                HasAttachments = mimeMessage.Attachments.Any(),
+                IsRead = !isUnread,
+                IsFlagged = isFlagged,
+                IsFocused = isFocused,
+                InReplyTo = mimeMessage.InReplyTo,
+                MessageId = mimeMessage.MessageId,
+                References = mimeMessage.References.GetReferences(),
+                FileId = Guid.NewGuid()
+            };
+        }
+
+        public static Tuple<MailCopy, MimeMessage, IEnumerable<string>> GetMailDetails(this Message message)
+        {
+            MimeMessage mimeMessage = message.GetGmailMimeMessage();
+
+            if (mimeMessage == null)
+            {
+                // This should never happen.
+                Debugger.Break();
+
+                return default;
+            }
+
+            bool isUnread = message.GetIsUnread();
+            bool isFocused = message.GetIsFocused();
+            bool isFlagged = message.GetIsFlagged();
+            bool isDraft = message.GetIsDraft();
+
+            var mailCopy = new MailCopy()
+            {
+                CreationDate = mimeMessage.Date.UtcDateTime,
+                Subject = HttpUtility.HtmlDecode(mimeMessage.Subject),
+                FromName = MailkitClientExtensions.GetActualSenderName(mimeMessage),
+                FromAddress = MailkitClientExtensions.GetActualSenderAddress(mimeMessage),
+                PreviewText = HttpUtility.HtmlDecode(message.Snippet),
+                ThreadId = message.ThreadId,
+                Importance = (MailImportance)mimeMessage.Importance,
+                Id = message.Id,
+                IsDraft = isDraft,
+                HasAttachments = mimeMessage.Attachments.Any(),
+                IsRead = !isUnread,
+                IsFlagged = isFlagged,
+                IsFocused = isFocused,
+                InReplyTo = mimeMessage.InReplyTo,
+                MessageId = mimeMessage.MessageId,
+                References = mimeMessage.References.GetReferences()
+            };
+
+            return new Tuple<MailCopy, MimeMessage, IEnumerable<string>>(mailCopy, mimeMessage, message.LabelIds);
+        }
+
+    }
+}

Wino.Core/Extensions/HtmlAgilityPackExtensions.cs

@@ -0,0 +1,121 @@
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using HtmlAgilityPack;
+
+namespace Wino.Core.Extensions
+{
+    public static class HtmlAgilityPackExtensions
+    {
+        /// <summary>
+        /// Clears out the src attribute for all `img` and `v:fill` tags.
+        /// </summary>
+        /// <param name="document"></param>
+        public static void ClearImages(this HtmlDocument document)
+        {
+            if (document.DocumentNode.InnerHtml.Contains("<img"))
+            {
+                foreach (var eachNode in document.DocumentNode.SelectNodes("//img"))
+                {
+                    eachNode.Attributes.Remove("src");
+                }
+            }
+        }
+
+        /// <summary>
+        /// Removes `style` tags from the document.
+        /// </summary>
+        /// <param name="document"></param>
+        public static void ClearStyles(this HtmlDocument document)
+        {
+            document.DocumentNode
+                    .Descendants()
+                    .Where(n => n.Name.Equals("script", StringComparison.OrdinalIgnoreCase)
+                    || n.Name.Equals("style", StringComparison.OrdinalIgnoreCase)
+                    || n.Name.Equals("#comment", StringComparison.OrdinalIgnoreCase))
+                    .ToList()
+                    .ForEach(n => n.Remove());
+        }
+
+        /// <summary>
+        /// Returns plain text from the HTML content.
+        /// </summary>
+        /// <param name="htmlContent">Content to get preview from.</param>
+        /// <returns>Text body for the html.</returns>
+        public static string GetPreviewText(string htmlContent)
+        {
+            if (string.IsNullOrEmpty(htmlContent)) return string.Empty;
+
+            HtmlDocument doc = new HtmlDocument();
+            doc.LoadHtml(htmlContent);
+
+            StringWriter sw = new StringWriter();
+            ConvertTo(doc.DocumentNode, sw);
+            sw.Flush();
+
+            return sw.ToString().Replace(Environment.NewLine, "");
+        }
+
+        private static void ConvertContentTo(HtmlNode node, TextWriter outText)
+        {
+            foreach (HtmlNode subnode in node.ChildNodes)
+            {
+                ConvertTo(subnode, outText);
+            }
+        }
+
+        private static void ConvertTo(HtmlNode node, TextWriter outText)
+        {
+            string html;
+            switch (node.NodeType)
+            {
+                case HtmlNodeType.Comment:
+                    // don't output comments
+                    break;
+
+                case HtmlNodeType.Document:
+                    ConvertContentTo(node, outText);
+                    break;
+
+                case HtmlNodeType.Text:
+                    // script and style must not be output
+                    string parentName = node.ParentNode.Name;
+                    if ((parentName == "script") || (parentName == "style"))
+                        break;
+
+                    // get text
+                    html = ((HtmlTextNode)node).Text;
+
+                    // is it in fact a special closing node output as text?
+                    if (HtmlNode.IsOverlappedClosingElement(html))
+                        break;
+
+                    // check the text is meaningful and not a bunch of whitespaces
+                    if (html.Trim().Length > 0)
+                    {
+                        outText.Write(HtmlEntity.DeEntitize(html));
+                    }
+                    break;
+
+                case HtmlNodeType.Element:
+                    switch (node.Name)
+                    {
+                        case "p":
+                            // treat paragraphs as crlf
+                            outText.Write("\r\n");
+                            break;
+                        case "br":
+                            outText.Write("\r\n");
+                            break;
+                    }
+
+                    if (node.HasChildNodes)
+                    {
+                        ConvertContentTo(node, outText);
+                    }
+                    break;
+            }
+        }
+    }
+}

Wino.Core/Extensions/ListExtensions.cs

@@ -0,0 +1,58 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Wino.Core.Domain.Enums;
+using Wino.Core.Domain.Interfaces;
+
+namespace Wino.Core.Extensions
+{
+    public static class ListExtensions
+    {
+        public static IEnumerable<T> FlattenBy<T>(this IEnumerable<T> nodes, Func<T, IEnumerable<T>> selector)
+        {
+            if (nodes.Any() == false)
+                return nodes;
+
+            var descendants = nodes
+                .SelectMany(selector)
+                .FlattenBy(selector);
+
+            return nodes.Concat(descendants);
+        }
+
+        public static IEnumerable<IBatchChangeRequest> CreateBatch(this IEnumerable<IGrouping<MailSynchronizerOperation, IRequestBase>> items)
+        {
+            IBatchChangeRequest batch = null;
+
+            foreach (var group in items)
+            {
+                var key = group.Key;
+            }
+
+            yield return batch;
+        }
+
+        public static void AddSorted<T>(this List<T> @this, T item) where T : IComparable<T>
+        {
+            if (@this.Count == 0)
+            {
+                @this.Add(item);
+                return;
+            }
+            if (@this[@this.Count - 1].CompareTo(item) <= 0)
+            {
+                @this.Add(item);
+                return;
+            }
+            if (@this[0].CompareTo(item) >= 0)
+            {
+                @this.Insert(0, item);
+                return;
+            }
+            int index = @this.BinarySearch(item);
+            if (index < 0)
+                index = ~index;
+            @this.Insert(index, item);
+        }
+    }
+}

Wino.Core/Extensions/LongExtensions.cs

@@ -0,0 +1,58 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Wino.Core.Extensions
+{
+    public static class LongExtensions
+    {
+        // Returns the human-readable file size for an arbitrary, 64-bit file size 
+        // The default format is "0.### XB", e.g. "4.2 KB" or "1.434 GB"
+        public static string GetBytesReadable(this long i)
+        {
+            // Get absolute value
+            long absolute_i = (i < 0 ? -i : i);
+            // Determine the suffix and readable value
+            string suffix;
+            double readable;
+            if (absolute_i >= 0x1000000000000000) // Exabyte
+            {
+                suffix = "EB";
+                readable = (i >> 50);
+            }
+            else if (absolute_i >= 0x4000000000000) // Petabyte
+            {
+                suffix = "PB";
+                readable = (i >> 40);
+            }
+            else if (absolute_i >= 0x10000000000) // Terabyte
+            {
+                suffix = "TB";
+                readable = (i >> 30);
+            }
+            else if (absolute_i >= 0x40000000) // Gigabyte
+            {
+                suffix = "GB";
+                readable = (i >> 20);
+            }
+            else if (absolute_i >= 0x100000) // Megabyte
+            {
+                suffix = "MB";
+                readable = (i >> 10);
+            }
+            else if (absolute_i >= 0x400) // Kilobyte
+            {
+                suffix = "KB";
+                readable = i;
+            }
+            else
+            {
+                return i.ToString("0 B"); // Byte
+            }
+            // Divide by 1024 to get fractional value
+            readable = (readable / 1024);
+            // Return formatted number with suffix
+            return readable.ToString("0.# ") + suffix;
+        }
+    }
+}

Wino.Core/Extensions/MailkitClientExtensions.cs

@@ -0,0 +1,187 @@
+using System;
+using System.Linq;
+using MailKit;
+using MimeKit;
+using Wino.Core.Domain;
+using Wino.Core.Domain.Entities;
+using Wino.Core.Domain.Enums;
+
+namespace Wino.Core.Extensions
+{
+    public static class MailkitClientExtensions
+    {
+        public static char MailCopyUidSeparator = '_';
+
+        public static uint ResolveUid(string mailCopyId)
+        {
+            var splitted = mailCopyId.Split(MailCopyUidSeparator);
+
+            if (splitted.Length > 1 && uint.TryParse(splitted[1], out uint parsedUint)) return parsedUint;
+
+            throw new ArgumentOutOfRangeException(nameof(mailCopyId), mailCopyId, "Invalid mailCopyId format.");
+        }
+
+        public static string CreateUid(Guid folderId, uint messageUid)
+            => $"{folderId}{MailCopyUidSeparator}{messageUid}";
+
+        public static MailImportance GetImportance(this MimeMessage messageSummary)
+        {
+            if (messageSummary.Headers != null && messageSummary.Headers.Contains(HeaderId.Importance))
+            {
+                var rawImportance = messageSummary.Headers[HeaderId.Importance];
+
+                return rawImportance switch
+                {
+                    "Low" => MailImportance.Low,
+                    "High" => MailImportance.High,
+                    _ => MailImportance.Normal,
+                };
+            }
+
+            return MailImportance.Normal;
+        }
+
+        public static bool GetIsRead(this MessageFlags? flags)
+            => flags.GetValueOrDefault().HasFlag(MessageFlags.Seen);
+
+        public static bool GetIsFlagged(this MessageFlags? flags)
+            => flags.GetValueOrDefault().HasFlag(MessageFlags.Flagged);
+
+        public static string GetThreadId(this IMessageSummary messageSummary)
+        {
+            // First check whether we have the default values.
+
+            if (!string.IsNullOrEmpty(messageSummary.ThreadId))
+                return messageSummary.ThreadId;
+
+            if (messageSummary.GMailThreadId != null)
+                return messageSummary.GMailThreadId.ToString();
+
+            return default;
+        }
+
+        public static string GetMessageId(this MimeMessage mimeMessage)
+            => mimeMessage.MessageId;
+
+        public static string GetReferences(this MessageIdList messageIdList)
+            => string.Join(";", messageIdList);
+
+        public static string GetInReplyTo(this MimeMessage mimeMessage)
+        {
+            if (mimeMessage.Headers.Contains(HeaderId.InReplyTo))
+            {
+                // Normalize if <> brackets are there.
+                var inReplyTo = mimeMessage.Headers[HeaderId.InReplyTo];
+
+                if (inReplyTo.StartsWith("<") && inReplyTo.EndsWith(">"))
+                    return inReplyTo.Substring(1, inReplyTo.Length - 2);
+
+                return inReplyTo;
+            }
+
+            return string.Empty;
+        }
+
+        private static string GetPreviewText(this MimeMessage message)
+        {
+            if (string.IsNullOrEmpty(message.HtmlBody))
+                return message.TextBody;
+            else
+                return HtmlAgilityPackExtensions.GetPreviewText(message.HtmlBody);
+        }
+
+        public static MailCopy GetMailDetails(this IMessageSummary messageSummary, MailItemFolder folder, MimeMessage mime)
+        {
+            // MessageSummary will only have UniqueId, Flags, ThreadId.
+            // Other properties are extracted directly from the MimeMessage.
+
+            // IMAP doesn't have unique id for mails.
+            // All mails are mapped to specific folders with incremental Id.
+            // Uid 1 may belong to different messages in different folders, but can never be
+            // same for different messages in same folders.
+            // Here we create arbitrary Id that maps the Id of the message with Folder UniqueId.
+            // When folder becomes invalid, we'll clear out these MailCopies as well.
+
+            var messageUid = CreateUid(folder.Id, messageSummary.UniqueId.Id);
+            var previewText = mime.GetPreviewText();
+
+            var copy = new MailCopy()
+            {
+                Id = messageUid,
+                CreationDate = mime.Date.UtcDateTime,
+                ThreadId = messageSummary.GetThreadId(),
+                MessageId = mime.GetMessageId(),
+                Subject = mime.Subject,
+                IsRead = messageSummary.Flags.GetIsRead(),
+                IsFlagged = messageSummary.Flags.GetIsFlagged(),
+                PreviewText = previewText,
+                FromAddress = GetActualSenderAddress(mime),
+                FromName = GetActualSenderName(mime),
+                IsFocused = false,
+                Importance = mime.GetImportance(),
+                References = mime.References?.GetReferences(),
+                InReplyTo = mime.GetInReplyTo(),
+                HasAttachments = mime.Attachments.Any(),
+                FileId = Guid.NewGuid()
+            };
+
+            return copy;
+        }
+
+        // TODO: Name and Address parsing should be handled better.
+        // At some point Wino needs better contact management.
+
+        public static string GetActualSenderName(MimeMessage message)
+        {
+            if (message == null)
+                return string.Empty;
+
+            // From MimeKit
+
+            // The "From" header specifies the author(s) of the message.
+            // If more than one MimeKit.MailboxAddress is added to the list of "From" addresses,
+            // the MimeKit.MimeMessage.Sender should be set to the single MimeKit.MailboxAddress
+            // of the personal actually sending the message.
+
+            // Also handle: https://stackoverflow.com/questions/46474030/mailkit-from-address
+
+            if (message.Sender != null)
+                return string.IsNullOrEmpty(message.Sender.Name) ? message.Sender.Address : message.Sender.Name;
+            else if (message.From?.Mailboxes != null)
+            {
+                var firstAvailableName = message.From.Mailboxes.FirstOrDefault(a => !string.IsNullOrEmpty(a.Name))?.Name;
+
+                if (string.IsNullOrEmpty(firstAvailableName))
+                {
+                    var firstAvailableAddress = message.From.Mailboxes.FirstOrDefault(a => !string.IsNullOrEmpty(a.Address))?.Address;
+
+                    if (!string.IsNullOrEmpty(firstAvailableAddress))
+                    {
+                        return firstAvailableAddress;
+                    }
+                }
+
+                return firstAvailableName;
+            }
+
+            // No sender, no from, I don't know what to do.
+            return Translator.UnknownSender;
+        }
+
+        // TODO: This is wrong.
+        public static string GetActualSenderAddress(MimeMessage mime)
+        {
+            if (mime == null)
+                return string.Empty;
+
+            bool hasSingleFromMailbox = mime.From.Mailboxes.Count() == 1;
+
+            if (hasSingleFromMailbox)
+                return mime.From.Mailboxes.First().GetAddress(idnEncode: true);
+            else if (mime.Sender != null)
+                return mime.Sender.GetAddress(idnEncode: true);
+            else
+                return Translator.UnknownSender;
+        }
+    }
+}

Wino.Core/Extensions/MailkitExtensions.cs

@@ -0,0 +1,22 @@
+using System;
+using MailKit;
+using Wino.Core.Domain.Entities;
+
+namespace Wino.Core.Extensions
+{
+    public static class MailkitExtensions
+    {
+        public static MailItemFolder GetLocalFolder(this IMailFolder mailkitMailFolder)
+        {
+            return new MailItemFolder()
+            {
+                Id = Guid.NewGuid(),
+                FolderName = mailkitMailFolder.Name,
+                RemoteFolderId = mailkitMailFolder.FullName,
+                ParentRemoteFolderId = mailkitMailFolder.ParentFolder?.FullName,
+                SpecialFolderType = Domain.Enums.SpecialFolderType.Other,
+                IsSynchronizationEnabled = true
+            };
+        }
+    }
+}

Wino.Core/Extensions/MimeExtensions.cs

@@ -0,0 +1,52 @@
+using System.IO;
+using System.Text;
+using Google.Apis.Gmail.v1.Data;
+using MimeKit;
+using MimeKit.IO;
+using MimeKit.IO.Filters;
+using Wino.Core.Domain;
+using Wino.Core.Domain.Entities;
+
+namespace Wino.Core.Extensions
+{
+    public static class MimeExtensions
+    {
+        /// <summary>
+        /// Returns MimeKit.MimeMessage instance for this GMail Message's Raw content.
+        /// </summary>
+        /// <param name="message">GMail message.</param>
+        public static MimeMessage GetGmailMimeMessage(this Message message)
+        {
+            if (message == null || message.Raw == null)
+                return null;
+
+            // Gmail raw is not base64 but base64Safe. We need to remove this HTML things.
+            var base64Encoded = message.Raw.Replace(",", "=").Replace("-", "+").Replace("_", "/");
+
+            byte[] bytes = Encoding.ASCII.GetBytes(base64Encoded);
+
+            var stream = new MemoryStream(bytes);
+
+            // This method will dispose outer stream.
+
+            using (stream)
+            {
+                using var filtered = new FilteredStream(stream);
+                filtered.Add(DecoderFilter.Create(ContentEncoding.Base64));
+
+                return MimeMessage.Load(filtered);
+            }
+        }
+
+        public static AddressInformation ToAddressInformation(this MailboxAddress address)
+        {
+            if (address == null)
+                return new AddressInformation() { Name = Translator.UnknownSender, Address = Translator.UnknownAddress };
+
+            if (string.IsNullOrEmpty(address.Name))
+                address.Name = address.Address;
+
+            return new AddressInformation() { Name = address.Name, Address = address.Address };
+        }
+    }
+}

Wino.Core/Extensions/OutlookIntegratorExtensions.cs

@@ -0,0 +1,65 @@
+using System;
+using Microsoft.Graph.Models;
+using Wino.Core.Domain.Entities;
+using Wino.Core.Domain.Enums;
+
+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;
+        }
+    }
+}

Wino.Core/Extensions/SqlKataExtensions.cs

@@ -0,0 +1,15 @@
+using SqlKata;
+using SqlKata.Compilers;
+
+namespace Wino.Core.Extensions
+{
+    public static class SqlKataExtensions
+    {
+        private static SqliteCompiler Compiler = new SqliteCompiler();
+
+        public static string GetRawQuery(this Query query)
+        {
+            return Compiler.Compile(query).ToString();
+        }
+    }
+}

Wino.Core/Extensions/StringExtensions.cs

@@ -0,0 +1,22 @@
+using System;
+
+namespace Wino.Core.Extensions
+{
+    public static class StringExtensions
+    {
+        public static bool Contains(this string source, string toCheck, StringComparison comp)
+        {
+            return source?.IndexOf(toCheck, comp) >= 0;
+        }
+
+        public static string ReplaceFirst(this string text, string search, string replace)
+        {
+            int pos = text.IndexOf(search);
+            if (pos < 0)
+            {
+                return text;
+            }
+            return text.Substring(0, pos) + replace + text.Substring(pos + search.Length);
+        }
+    }
+}

Wino.Core/Extensions/TokenizationExtensions.cs

@@ -0,0 +1,31 @@
+using System;
+using Microsoft.Identity.Client;
+using Wino.Core.Domain.Entities;
+
+namespace Wino.Core.Extensions
+{
+    public static class TokenizationExtensions
+    {
+        public static TokenInformation CreateTokenInformation(this AuthenticationResult clientBuilderResult)
+        {
+            var expirationDate = clientBuilderResult.ExpiresOn.UtcDateTime;
+            var accesToken = clientBuilderResult.AccessToken;
+            var userName = clientBuilderResult.Account.Username;
+
+            // MSAL does not expose refresh token for security reasons.
+            // This token info will be created without refresh token.
+            // but OutlookIntegrator will ask for publicApplication to refresh it
+            // in case of expiration.
+
+            var tokenInfo = new TokenInformation()
+            {
+                ExpiresAt = expirationDate,
+                AccessToken = accesToken,
+                Address = userName,
+                Id = Guid.NewGuid(),
+            };
+
+            return tokenInfo;
+        }
+    }
+}