xIdentityService/Partial/XIdentityProvider+Open.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Threading.Tasks;
using MongoDB.Bson;
using xCommons.Constants;
using xCommons.Extensions;
using xExceptions.Constants;
using xHttpService.Constants;
using xIdentityModels.Dtos;
using xIdentityService.Constants;
using xModels.Dtos;

namespace xIdentityService.Providers
{
    public partial class XIdentityProvider
    {
        /// <summary>
        /// Prepare API Based Device to Open Actions ...
        /// </summary>
        /// <returns></returns>
        public  XDeviceDto GetDevice()
        {
            //
            var os = "XSaherElmOS";
            bool isOSX = RuntimeInformation.IsOSPlatform(OSPlatform.OSX);
            bool isLinux = RuntimeInformation.IsOSPlatform(OSPlatform.Linux);
            bool isWindows = RuntimeInformation.IsOSPlatform(OSPlatform.Windows);
            if (isOSX)
            {
                os = "MacOs";
            }
            else if (isLinux)
            {
                os = "Linux";
            }
            else if (isWindows)
            {
                os = "Windows";
            }
            var agent = RuntimeInformation.FrameworkDescription;
            if (agent.IsNullOrEmpty())
            {
                agent = "XSaherElmOSAgent";
            }
            var version = RuntimeInformation.OSArchitecture + ", " + RuntimeInformation.OSDescription;
            if (version.IsNullOrEmpty())
            {
                version = "XSaherElmOSVersion";
            }
            var browser = "XSaherElmBrowser_" + RevisionSecretKey.ToMd5String();

            //
            var result = new XDeviceDto
            {
                Os = os,
                Browser = browser,
                UserAgent = agent,
                OsVersion = version,
                DeviceType = XDeviceType.Desktop,
            };

            //
            return result;
        }

        //
        #region OpenGet ...
        public async Task<XOpenActionInnerDto> OpenGet(
            XOpenActionInnerDto model
        )
        {
            //
            // Validate Args ...
            await validationProvider
                .GroupValidationBuilder()
                .AddNotNull(model)
                .AddNotEmpty(model.Token)
                .AddNotEmpty(model.Payload)
                .ValidateGroupAsync();

            //
            var result = await OpenGet(
                token: model.Token,
                actionRequest: model.Payload
            );

            //
            return result;
        }
        public async Task<XOpenActionInnerDto> OpenGet(
            string token,
            string actionRequest
        )
        {
            //
            // Validate Args ...
            await validationProvider
                .GroupValidationBuilder()
                .AddNotEmpty(token)
                .AddNotEmpty(actionRequest)
                .ValidateGroupAsync();

            //
            // Retrieve Rest Client ...
            var client = GetRestClient();

            //
            // Prepare Rest Request ...
            var request = GetRestRequet(
                XApiAccountEndpoint.Open,
                headers: new Dictionary<string, string>
                {
                    { XAuthentication.TOKEN, token}
                },
                queryStrings: new Dictionary<string, string>
                {
                    { XParam.XRequest.GetStringValue(), actionRequest }
                }
            );

            //
            // Run Request and Retrieve Response ...
            var response = await RunRestRequestByResponse<string>(
                client,
                request,
                XHttpMethod.GET
            );

            //
            // Now we Have to Validate the recieved response ...

            //
            // Read token from Headers ...
            var responseToken = response.Response.Headers
                .First(h => h.Name == XAuthentication.TOKEN).Value.ToString();
            if (responseToken.IsNullOrEmpty())
            {
                XException.ActionFailed.Throw();
            }

            //
            // Decript Recieve Response ...
            var responseJson = response.Model; // SecurityProvider.Decrypt(response.Model);
            if (responseJson.IsNullOrEmpty())
            {
                XException.ActionFailed.Throw();
            }

            //
            var result = new XOpenActionInnerDto
            {
                Token = responseToken,
                Payload = responseJson
            };

            //
            // Retrieve Model and Validate it ...
            var responseModel = responseJson.FromJSON<XOpenActionRequestDto>();
            if (responseModel.IsNull() ||
                responseModel.Payload.IsNullOrEmpty() ||
                responseToken != responseModel.Checksum ||
                responseModel.Timestamp.FromTimestamp().IsExPired())
            {
                XException.ActionFailed.Throw();
            }

            //
            return result;
        }
        #endregion

        //
        #region GetUserInfo ...
        public async Task<XOpenActionUserInfoDto> GetUserInfo(
            XDeviceDto device,
            string userSelectByParam
        )
        {
            //
            // Validate Args ...
            validationProvider.NotNull(device);
            validationProvider.NotEmpty(userSelectByParam);

            //
            // Prepare Open Action Model ...
            var opaModel = new XOpenActionRequestDto
            {
                Device = device,
                Payload = userSelectByParam,
                Action = XOpenActions.GetUserInfo,
                Timestamp = DateTime.UtcNow.AddMinutes(5).ToTimestamp().ToString()
            };
            if (!opaModel.Validate())
            {
                XException.InvalidArgs.Throw();
            }

            //
            // Fill Checksum Filed ...
            var token = opaModel.ToOpenActionToken();
            opaModel.Checksum = token;

            //
            // Prepare Request ...
            var opaJson = opaModel.ToJson();
            var requestString = SecurityProvider.Encrypt(opaJson);

            //
            return await GetUserInfo(
                token: token,
                request: requestString
            );
        }

        public async Task<XOpenActionUserInfoDto> GetUserInfo(
            XOpenActionInnerDto dto
        )
        {
            //
            return await GetUserInfo(
                token: dto.Token,
                request: dto.Payload
            );
        }

        public async Task<XOpenActionUserInfoDto> GetUserInfo(
            string token,
            string request
        )
        {
            //
            // Validate Args ...
            validationProvider.NotEmpty(token);
            validationProvider.NotEmpty(request);

            //
            // Retrieve and Validate Response ...
            var response = await OpenGet(
                token: token,
                actionRequest: request
            );
            if (response.IsNull() ||
                response.Token.IsNullOrEmpty() ||
                response.Payload.IsNullOrEmpty())
            {
                XException.ActionFailed.Throw();
            }

            //
            // Now we Have to Converts Repose Payload to Result Model ...
            // Note that the respose Model's payload here is Decrypted and
            // actually is Json Representation of Result Model ...
            var requestModel = response.Payload.FromJSON<XOpenActionRequestDto>();
            if (requestModel.IsNull())
            {
                XException.ActionFailed.Throw();
            }

            //
            var resultJson = SecurityProvider.Decrypt(requestModel.Payload);
            var result = resultJson.FromJSON<XOpenActionUserInfoDto>();
            if (result.IsNull())
            {
                XException.NotFound.Throw();
            }

            //
            return result;
        }
        #endregion

        //
        #region GetUserInfos ...
        public async Task<IEnumerable<XOpenActionUserInfoDto>> GetUserInfos(
            XDeviceDto device,
            string ids
        )
        {
            //
            // Validate Args ...
            validationProvider.NotNull(device);
            validationProvider.NotEmpty(ids);

            //
            // Prepare Open Action Model ...
            var opaModel = new XOpenActionRequestDto
            {
                Payload = ids,
                Device = device,
                Action = XOpenActions.GetUserInfos,
                Timestamp = DateTime.UtcNow.AddMinutes(5).ToTimestamp().ToString()
            };
            if (!opaModel.Validate())
            {
                XException.InvalidArgs.Throw();
            }

            //
            // Fill Checksum Filed ...
            var token = opaModel.ToOpenActionToken();
            opaModel.Checksum = token;

            //
            // Prepare Request ...
            var opaJson = opaModel.ToJson();
            var requestString = SecurityProvider.Encrypt(opaJson);

            //
            return await GetUserInfos(
                token: token,
                request: requestString
            );
        }

        public async Task<IEnumerable<XOpenActionUserInfoDto>> GetUserInfos(
            XOpenActionInnerDto dto
        )
        {
            //
            return await GetUserInfos(
                token: dto.Token,
                request: dto.Payload
            );
        }

        public async Task<IEnumerable<XOpenActionUserInfoDto>> GetUserInfos(
            string token,
            string request
        )
        {
            //
            // Validate Args ...
            validationProvider.NotEmpty(token);
            validationProvider.NotEmpty(request);

            //
            // Retrieve and Validate Response ...
            var response = await OpenGet(
                token: token,
                actionRequest: request
            );
            if (response.IsNull() ||
                response.Token.IsNullOrEmpty() ||
                response.Payload.IsNullOrEmpty())
            {
                XException.ActionFailed.Throw();
            }

            //
            // Now we Have to Converts Repose Payload to Result Model ...
            // Note that the respose Model's payload here is Decrypted and
            // actually is Json Representation of Result Model ...
            var requestModel = response.Payload.FromJSON<XOpenActionRequestDto>();
            if (requestModel.IsNull())
            {
                XException.ActionFailed.Throw();
            }

            //
            var resultJson = SecurityProvider.Decrypt(requestModel.Payload);
            var result = resultJson.FromJSON<IEnumerable<XOpenActionUserInfoDto>>();
            if (result.IsNull())
            {
                XException.NotFound.Throw();
            }

            //
            return result;
        }
        #endregion
    }
}