RegexBot/EntityCache/CacheUser.cs

using Discord.WebSocket;
using Npgsql;
using System;
using System.Collections.Generic;
using System.Data.Common;
using System.Linq;
using System.Text.RegularExpressions;
using System.Threading.Tasks;

namespace Noikoio.RegexBot.EntityCache
{
    /// <summary>
    /// Representation of a cached user.
    /// </summary>
    class CacheUser
    {
        readonly ulong _userId;
        readonly ulong _guildId;
        readonly DateTime _cacheDate;
        readonly string _username;
        readonly string _discriminator;
        readonly string _nickname;
        readonly string _avatarUrl;

        /// <summary>
        /// The cached user's ID (snowflake) value.
        /// </summary>
        public ulong UserId => _userId;
        /// <summary>
        /// The guild ID (snowflake) for which this user information corresponds to.
        /// </summary>
        public ulong GuildId => _guildId;
        /// <summary>
        /// Timestamp value for when this cache item was last updated, in universal time.
        /// </summary>
        public DateTime CacheDate => _cacheDate;

        /// <summary>
        /// Display name, including discriminator. Shows the nickname, if available.
        /// </summary>
        public string DisplayName => (_nickname ?? _username) + "#" + _discriminator;
        /// <summary>
        /// String useful for tagging the user.
        /// </summary>
        public string Mention => $"<@{_userId}>";
        /// <summary>
        /// User's cached nickname in the guild. May be null.
        /// </summary>
        public string Nickname => _nickname;
        /// <summary>
        /// User's cached username.
        /// </summary>
        public string Username => _username;
        /// <summary>
        /// User's cached discriminator value.
        /// </summary>
        public string Discriminator => _discriminator;
        /// <summary>
        /// URL for user's last known avatar. May be null or invalid.
        /// </summary>
        public string AvatarUrl => _avatarUrl;

        private CacheUser(SocketGuildUser u)
        {
            _userId = u.Id;
            _guildId = u.Guild.Id;
            _cacheDate = DateTime.UtcNow;
            _username = u.Username;
            _discriminator = u.Discriminator;
            _nickname = u.Nickname;
            _avatarUrl = u.GetAvatarUrl();
        }

        // Double-check SqlHelper if making changes to this constant
        const string QueryColumns = "user_id, guild_id, cache_date, username, discriminator, nickname, avatar_url";
        private CacheUser(DbDataReader r)
        {
            // Double-check ordinals if making changes to QueryColumns
            unchecked
            {
                // PostgreSQL does not support unsigned 64-bit numbers. Must convert.
                _userId = (ulong)r.GetInt64(0);
                _guildId = (ulong)r.GetInt64(1);
            }
            _cacheDate = r.GetDateTime(2).ToUniversalTime();
            _username = r.GetString(3);
            _discriminator = r.GetString(4);
            _nickname = r.IsDBNull(5) ? null : r.GetString(5);
            _avatarUrl = r.IsDBNull(6) ? null : r.GetString(6);
        }

        public override string ToString() => DisplayName;

        #region Queries
        // Accessible by EntityCache. Documentation is there.
        internal static async Task<CacheUser> QueryAsync(DiscordSocketClient c, ulong guild, ulong user)
        {
            // Local cache search
            var lresult = LocalQueryAsync(c, guild, user);
            if (lresult != null) return lresult;

            // Database cache search
            var db = await RegexBot.Config.GetOpenDatabaseConnectionAsync();
            if (db == null) return null; // Database not available for query.
            using (db) return await DbQueryAsync(db, guild, user);
        }

        private static CacheUser LocalQueryAsync(DiscordSocketClient c, ulong guild, ulong user)
        {
            var u = c.GetGuild(guild)?.GetUser(user);
            if (u == null) return null;
            return new CacheUser(u);
        }
        private static async Task<CacheUser> DbQueryAsync(NpgsqlConnection db, ulong guild, ulong user)
        {
            using (db)
            {
                using (var c = db.CreateCommand())
                {
                    c.CommandText = $"SELECT {QueryColumns} FROM {SqlHelper.TableUser} WHERE "
                        + "user_id = @Uid AND guild_id = @Gid";
                    c.Parameters.Add("@Uid", NpgsqlTypes.NpgsqlDbType.Bigint).Value = user;
                    c.Parameters.Add("@Gid", NpgsqlTypes.NpgsqlDbType.Bigint).Value = guild;
                    c.Prepare();
                    using (var r = await c.ExecuteReaderAsync())
                    {
                        if (await r.ReadAsync())
                        {
                            return new CacheUser(r);
                        }
                        else
                        {
                            return null;
                        }
                    }
                }
            }
        }

        // -----

        private static Regex DiscriminatorSearch = new Regex(@"(.+)#(\d{4}(?!\d))", RegexOptions.Compiled);
        // Accessible by EntityCache. Documentation is there.
        internal static async Task<IEnumerable<CacheUser>> QueryAsync(DiscordSocketClient c, ulong guild, string search)
        {
            // Is search just a number? Assume ID, pass it on to the correct place.
            if (ulong.TryParse(search, out var presult))
            {
                var r = await QueryAsync(c, guild, presult);
                if (r == null) return new CacheUser[0];
                else return new CacheUser[] { r };
            }

            // Split name/discriminator
            string name;
            string disc;
            var split = DiscriminatorSearch.Match(search);
            if (split.Success)
            {
                name = split.Groups[1].Value;
                disc = split.Groups[2].Value;
            }
            else
            {
                name = search;
                disc = null;
            }

            // Strip leading @ from name, if any
            if (name.Length > 0 && name[0] == '@') name = name.Substring(1);

            // Local cache search
            var lresult = LocalQueryAsync(c, guild, name, disc);
            if (lresult.Count() != 0) return lresult;

            // Database cache search
            var db = await RegexBot.Config.GetOpenDatabaseConnectionAsync();
            if (db == null) return null; // Database not available for query.
            using (db) return await DbQueryAsync(db, guild, name, disc);
        }

        private static IEnumerable<CacheUser> LocalQueryAsync(DiscordSocketClient c, ulong guild, string name, string disc)
        {
            var g = c.GetGuild(guild);
            if (g == null) return new CacheUser[] { };

            bool Filter(string iun, string inn, string idc)
            {
                // Same logic as in the SQL query in the method below this one
                bool match =
                    string.Equals(iun, name, StringComparison.InvariantCultureIgnoreCase)
                    || string.Equals(inn, name, StringComparison.InvariantCultureIgnoreCase);

                if (match && disc != null)
                    match = idc.Equals(disc);

                return match;
            }

            var qresult = g.Users.Where(i => Filter(i.Username, i.Nickname, i.Discriminator));
            var result = new List<CacheUser>();
            foreach (var item in qresult)
            {
                result.Add(new CacheUser(item));
            }
            return result;
        }

        private static async Task<IEnumerable<CacheUser>> DbQueryAsync(NpgsqlConnection db, ulong guild, string name, string disc)
        {
            var result = new List<CacheUser>();

            using (db = await RegexBot.Config.GetOpenDatabaseConnectionAsync())
            {
                using (var c = db.CreateCommand())
                {
                    c.CommandText = $"SELECT {QueryColumns} FROM {SqlHelper.TableUser} WHERE"
                        + " ( lower(username) = lower(@NameSearch) OR lower(nickname) = lower(@NameSearch) )";
                    if (disc != null)
                    {
                        c.CommandText += " AND discriminator = @DiscSearch";
                        c.Parameters.Add("@DiscSearch", NpgsqlTypes.NpgsqlDbType.Text).Value = disc;
                    }
                    c.CommandText += " ORDER BY cache_date desc, username";
                    c.Parameters.Add("@NameSearch", NpgsqlTypes.NpgsqlDbType.Text).Value = name;
                    
                    c.Prepare();

                    using (var r = await c.ExecuteReaderAsync())
                    {
                        while (await r.ReadAsync())
                        {
                            result.Add(new CacheUser(r));
                        }
                    }
                }
            }
            return result;
        }
        #endregion
    }
}