xPushService/Store/XPushConnectionInMemoryStore.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using xCommons.Extensions;
using xExceptions.Constants;
using xModels.Base;
using xModels.Dtos;
using xModels.Providers;
using xPushService.Interfaces;
using xPushService.Models;

namespace xPushService.Store
{
    public class XPushConnectionInMemoryStore : XBaseInMemoryStore<XPushConnectionDto, string>, IXPushConnectionStore
    {
        //
        #region Constructor ...
        public XPushConnectionInMemoryStore(
            IXPushConnectionStoreEvents events = null
        ) : base(events) {}
        #endregion

        //
        #region Custom ...
        /// <summary>
        /// retrieve specific connection by it's Id ...
        /// </summary>
        /// <param name="connectionId"></param>
        /// <returns></returns>
        public Task<XPushConnectionDto> GetByConnectionId(string connectionId)
        {
            return Get(connectionId);
        }

        /// <summary>
        /// retrieve specific user's connections ...
        /// </summary>
        /// <param name="userName"></param>
        /// <returns></returns>
        public Task<IEnumerable<XPushConnectionDto>> GetByUserName(string userName)
        {
            return FindMany(c => c.User.ToNormalString() == userName.ToNormalString());
        }

        /// <summary>
        /// retrieve specific user's connected device connection
        /// </summary>
        /// <param name="userName"></param>
        /// <param name="device"></param>
        /// <returns></returns>
        public Task<XPushConnectionDto> GetByUserDevice(string userName, XDeviceDto device)
        {
            return FindOne(c =>
                c.User.ToNormalString() == userName.ToNormalString() &&
                c.Device.IsSameContent(
                    device, null, null, null, false
                )
            );
        }

        /// <summary>
        /// check a connection exists or not by it's id ...
        /// </summary>
        /// <param name="connectionId"></param>
        /// <returns></returns>
        public Task<bool> IsExistsConnectionId(string connectionId)
        {
            return IsExistsByKey(connectionId);
        }

        /// <summary>
        /// check specific user connected or not ...
        /// </summary>
        /// <param name="userName"></param>
        /// <returns></returns>
        public Task<bool> IsExistsUser(string userName)
        {
            return GetByUserName(userName)
                .ContinueWith(findTask =>
                {
                    //
                    var findResult = findTask
                        .RunTask();

                    //
                    var result = findResult.Any();
                    return result;
                });
        }

        /// <summary>
        /// retrieve specific user's connected devices ...
        /// </summary>
        /// <param name="userName"></param>
        /// <param name="device"></param>
        /// <returns></returns>
        public Task<IEnumerable<XDeviceDto>> GetUserDevices(string userName)
        {
            return GetByUserName(userName)
                .ContinueWith(userConnectionsTask =>
                {
                    //
                    var userConnections = userConnectionsTask
                        .RunTask();

                    //
                    var result = userConnections.Select(c => c.Device);
                    return result;
                });
        }

        /// <summary>
        /// remove specific connection by it's id ...
        /// </summary>
        /// <param name="connectionId"></param>
        /// <returns></returns>
        public Task<bool> RemoveByConnectionId(string connectionId)
        {
            return RemoveByKey(connectionId);
        }

        /// <summary>
        /// remove specified user's connected device connection ...
        /// </summary>
        /// <param name="userName"></param>
        /// <param name="device"></param>
        /// <returns></returns>
        public Task<bool> RemoveByUserDevice(string userName, XDeviceDto device)
        {
            return GetByUserDevice(
                    device: device,
                    userName: userName
                )
                .ContinueWith(connectionTask =>
                {
                    //
                    var connection = connectionTask
                        .RunTask();

                    //
                    if (connection.IsNull())
                    {
                        return false;
                    }

                    //
                    var result = Remove(connection)
                        .RunTask();
                    return result;
                });
        }

        /// <summary>
        /// remove specific user's all connected devices ...
        /// </summary>
        /// <param name="userName"></param>
        /// <returns></returns>
        public Task<bool> RemoveUser(string userName)
        {
            return GetByUserName(userName)
                .ContinueWith(connectionsTask =>
                {
                    //
                    var connections = connectionsTask
                        .RunTask();

                    //
                    if (!connections.HasChild())
                    {
                        return false;
                    }

                    //
                    var result = RemoveMany(new XBaseRangeRequest<XPushConnectionDto>
                    {
                        Items = connections
                    })
                        .RunTask();

                    //
                    return result;
                });
        }

        /// <summary>
        /// Get specific connections last seen ...
        /// </summary>
        /// <param name="connectionId"></param>
        /// <returns></returns>
        public Task<DateTime> GetLastSeenByConnectionId(string connectionId)
        {
            return GetByConnectionId(connectionId)
                .ContinueWith(connectionTask =>
                {
                    //
                    var connection = connectionTask
                        .RunTask();

                    //
                    if (connection.IsNull())
                    {
                        throw XException.NotFound.ToException();
                    }

                    //
                    var result = connection.LastSeen;
                    return result;
                });
        }

        /// <summary>
        /// get specific user's last seen ...
        /// </summary>
        /// <param name="userName"></param>
        /// <returns></returns>
        public Task<DateTime> GetLastSeenByUserName(string userName)
        {
            return GetByUserName(userName)
                .ContinueWith(connectionsTask =>
                {
                    //
                    var connections = connectionsTask
                        .RunTask();

                    //
                    if (!connections.HasChild())
                    {
                        throw XException.NotFound.ToException();
                    }

                    //
                    var result = connections
                        .Select(c => c.LastSeen)
                        .Max();

                    //
                    return result;
                });
        }

        /// <summary>
        /// get specific user's connected device last seen ...
        /// </summary>
        /// <param name="userName"></param>
        /// <param name="device"></param>
        /// <returns></returns>
        public Task<DateTime> GetLastSeenByUserDevice(string userName, XDeviceDto device)
        {
            return GetByUserDevice(
                    device: device,
                    userName: userName
                )
                .ContinueWith(connectionTask =>
                {
                    //
                    var connection = connectionTask
                        .RunTask();

                    //
                    if (connection.IsNull())
                    {
                        throw XException.NotFound.ToException();
                    }

                    //
                    var result = connection.LastSeen;
                    return result;
                });
        }

        /// <summary>
        /// Update Connection last seen ...
        /// </summary>
        /// <param name="connectionId"></param>
        /// <returns></returns>
        public Task<bool> UpdateLastSeen(string connectionId)
        {
            return IsExistsConnectionId(connectionId)
                .ContinueWith(isExistsTask =>
                {
                    //
                    // define empty result ...
                    var result = false;

                    //
                    // run task and get result ...
                    result = isExistsTask
                        .RunTask();

                    //
                    // check result is false ...
                    if (!result)
                    {
                        return result;
                    }

                    //
                    // retreive connection ...
                    var connection = GetByConnectionId(connectionId)
                        .RunTask();
                    result = !connection.IsNull();
                    if (!result)
                    {
                        return result;
                    }

                    //
                    // Update Connection last seen ...
                    connection.LastSeen = DateTime.UtcNow;
                    var updatedConnection = Update(connection)
                        .RunTask();
                    result = !updatedConnection.IsNull();

                    //
                    return result;
                });
        }
        #endregion
    }
}