xIdentityService/Partial/XIdentityProvider+Registration.cs

using System.Collections.Generic;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Http;
using xCommons.Extensions;
using xExceptions.Constants;
using xHttpService.Constants;
using xIdentityModels.Constants;
using xIdentityModels.Extensions;
using xIdentityModels.Models;
using xIdentityService.Constants;

namespace xIdentityService.Providers {
    public partial class XIdentityProvider {
        //
        #region Registration ...
        /// <summary>
        /// Check a User Selector is Available for Registration or Not
        /// </summary>
        /// <param name="userSelectByParam">an string value which reperesent a user</param>
        /// <returns>a boolean value</returns>
        public async Task<bool> CanRegister (string userSelectByParam) {
            //
            // Validate ARgs ...
            validationProvider.NotEmpty (userSelectByParam);

            //
            var client = GetRestClient ();

            //
            // Check Endpoint ...
            var endpoint = XApiAccountEndpoint.CanRegisterUserName;
            var @params = new Dictionary<string, string> { { XParam.XUserName.GetStringValue (), userSelectByParam } };

            //
            // Check UserSelectByType ...
            var type = userSelectByParam.GetUserSelectByType ();
            switch (type) {
                //
                case XUserSelectBy.Username:
                    break;

                    //
                case XUserSelectBy.MobileNumber:
                    //
                    endpoint = XApiAccountEndpoint.CanRegisterMobileNumber;
                    @params = new Dictionary<string, string> { { XParam.XMobileNumber.GetStringValue (), userSelectByParam } };
                    break;

                    //
                case XUserSelectBy.Email:
                    //
                    endpoint = XApiAccountEndpoint.CanRegisterEmail;
                    @params = new Dictionary<string, string> { { XParam.XEmail.GetStringValue (), userSelectByParam } };
                    break;

                    //
                default:
                    throw XException.InvalidData.ToException ();
            }

            //
            var request = GetRestRequet (
                endpoint,
                @params: @params
            );

            //
            var response = await RunRestRequest<bool> (
                client,
                request,
                XHttpMethod.GET
            );
            return response;
        }

        /// <summary>
        /// Invite a User to Register on Dashboard
        /// </summary>
        /// <param name="tokens">Authentication Tokens</param>
        /// <param name="model">an instance of <see>XActionRequest</see> class which provider requirement for action</param>
        /// <returns>an instance of <see>XActionResponse</see></returns>
        public async Task<XActionResponse> InviteUser (
            XTokenResponse tokens,
            XActionRequest model
        ) {
            //
            // Validate Args ...
            await validationProvider
                .GroupValidationBuilder ()
                .AddNotNull (
                    tokens,
                    model,
                    model.Device)
                .AddNotEmpty (
                    tokens.AccessToken,
                    model.Lang,
                    model.Email,
                    model.ReturnUrl)
                .AddEmailAddress (model.Email)
                .ValidateGroupAsync ();

            //
            var client = GetRestClient (tokens);

            //
            var request = GetRestRequet (XApiAccountEndpoint.InviteUser);
            request.AddJsonBody (model);

            //
            var response = await RunRestRequest<XActionResponse> (
                client,
                request,
                XHttpMethod.POST
            );
            return response;
        }

        /// <summary>
        /// Recieve some Basic Informations and Start Registration Proccess
        /// if they Valid 
        /// 
        /// Registration Proccess Starts with Invoking this Action
        /// </summary>
        /// <param name="model">an instance of <see>XActionRequest</see> class which provider requirement for action</param>
        /// <returns>an instance of <see>XActionResponse</see></returns>
        public async Task<XActionResponse> RequestRegistration (
            XActionRequest model
        ) {
            //
            // Validate Args ...
            await validationProvider
                .GroupValidationBuilder ()
                .AddNotNull (
                    model,
                    model.Device,
                    model.DateOfBirth)
                .AddNotEmpty (
                    model.Lang,
                    model.FirstName,
                    model.LastName)
                .ValidateGroupAsync ();

            //
            var client = GetRestClient ();

            //
            var request = GetRestRequet (XApiAccountEndpoint.RequestRegistration);
            request.AddJsonBody (model);

            //
            var response = await RunRestRequest<XActionResponse> (
                client,
                request,
                XHttpMethod.POST
            );
            return response;
        }

        /// <summary>
        /// Add User Account Informations
        /// </summary>
        /// <param name="model">an instance of <see>XActionRequest</see> class which provider requirement for action</param>
        /// <returns>an instance of <see>XActionResponse</see></returns>
        public async Task<XActionResponse> AddAccountInfo (
            XActionRequest model
        ) {
            //
            // Validate Args ...
            await validationProvider
                .GroupValidationBuilder ()
                .AddNotNull (
                    model,
                    model.Device)
                .AddNotEmpty (
                    model.Lang,
                    model.UserName,
                    model.Password,
                    model.ActionToken)
                .ValidateGroupAsync ();

            //
            var client = GetRestClient ();

            //
            var request = GetRestRequet (XApiAccountEndpoint.AddAccountInfo);
            request.AddJsonBody (model);

            //
            var response = await RunRestRequest<XActionResponse> (
                client,
                request,
                XHttpMethod.POST
            );
            return response;
        }

        /// <summary>
        /// Upload and Attach a Profile Image for User. this is an Optional Step
        /// </summary>
        /// <param name="actionToken">user's requested action token</param>
        /// <param name="file">an instance of <see>IFormFile</see> for user's Avatar</param>
        /// <returns>an instance of <see>XActionResponse</see></returns>
        public async Task<XActionResponse> AttachProfileImage (
            string actionToken,
            IFormFile file
        ) {
            //
            // Validate Args ...
            await validationProvider
                .GroupValidationBuilder ()
                .AddNotNull (file)
                .AddNotEmpty (actionToken)
                .ValidateGroupAsync ();

            //
            var client = GetRestClient ();

            //
            var request = GetRestRequet (XApiAccountEndpoint.AttachProfileImage);

            //
            // Prepare Request Data ...
            request.AddParameter (XParam.XActionToken.GetStringValue (), actionToken);
            request.AddFileBytes (
                XParam.XFile.GetStringValue (),
                file.ToByteArray (),
                file.FileName,
                file.ContentType
            );

            //
            var response = await RunRestRequest<XActionResponse> (
                client,
                request,
                XHttpMethod.POST
            );
            return response;
        }

        /// <summary>
        /// Finish Registrationn Proccess 
        /// </summary>
        /// <param name="model">an instance of <see>XActionRequest</see> class which provider requirement for action</param>
        /// <returns></returns>
        public async Task FinishRegistration (XActionRequest model) {
            //
            // Validate Args ...
            await validationProvider
                .GroupValidationBuilder ()
                .AddNotEmpty (
                    model.Lang,
                    model.Password,
                    model.ReturnUrl)
                .AddNotNull (model.Device)
                .AddUrl (model.ReturnUrl)
                .ValidateGroupAsync ();

            //
            // Create Http Client ...
            var client = GetRestClient ();

            //
            // Create Request ...
            var request = GetRestRequet (XApiAccountEndpoint.FinishRegistration);

            //
            // Prepare Request Data ...
            request.AddJsonBody (model);

            //
            var response = await RunRestRequest<object> (
                client,
                request,
                XHttpMethod.POST
            );
        }

        /// <summary>
        /// Check User is Confirmed Email or not
        /// </summary>
        /// <param name="tokens">Authentication Tokens</param>
        /// <param name="userSelectByParam">an string value which reperesent a user</param>
        /// <returns>a boolean value</returns>
        public async Task<bool> IsConfirmedEmail (
            XTokenResponse tokens,
            string userSelectByParam
        ) {
            //
            // Validate Args ...
            await validationProvider
                .GroupValidationBuilder ()
                .AddNotNull (tokens)
                .AddNotEmpty (
                    tokens.AccessToken,
                    userSelectByParam)
                .ValidateGroupAsync ();

            //
            var client = GetRestClient (tokens);

            //
            var request = GetRestRequet (XApiAccountEndpoint.IsConfirmedEmail);

            //
            var response = await RunRestRequest<bool> (
                client,
                request,
                XHttpMethod.GET
            );
            return response;
        }

        /// <summary>
        /// Check User is Confirmed Mobile or not
        /// </summary>
        /// <param name="tokens">Authentication Tokens</param>
        /// <param name="userSelectByParam">an string value which reperesent a user</param>
        /// <returns>a boolean value</returns>
        public async Task<bool> IsConfirmedMobile (
            XTokenResponse tokens,
            string userSelectByParam
        ) {
            //
            // Validate Args ...
            await validationProvider
                .GroupValidationBuilder ()
                .AddNotNull (tokens)
                .AddNotEmpty (
                    tokens.AccessToken,
                    userSelectByParam)
                .ValidateGroupAsync ();

            //
            var client = GetRestClient (tokens);

            //
            var request = GetRestRequet (XApiAccountEndpoint.IsConfirmedMobile);

            //
            var response = await RunRestRequest<bool> (
                client,
                request,
                XHttpMethod.GET
            );
            return response;
        }

        /// <summary>
        /// Request Registration Confirm
        /// </summary>
        /// <param name="model">an instance of <see>XActionRequest</see> class which provider requirement for action</param>
        /// <returns></returns>
        public async Task RequestConfirmRegistration (XActionRequest model) {
            //
            // Validate Args ...
            await validationProvider
                .GroupValidationBuilder ()
                .AddNotEmpty (
                    model.Lang,
                    model.Password,
                    model.ReturnUrl)
                .AddNotNull (model.Device)
                .AddUrl (model.ReturnUrl)
                .ValidateGroupAsync ();

            //
            // Get UserSelect By Param ...
            var userSelectByParam = model.GetUserSelectByParam ();
            validationProvider.NotEmpty (userSelectByParam);

            //
            var client = GetRestClient ();

            //
            var request = GetRestRequet (XApiAccountEndpoint.RequestConfirmRegistration);
            request.AddJsonBody (model);

            //
            var response = await RunRestRequest<object> (
                client,
                request,
                XHttpMethod.POST
            );
        }

        /// <summary>
        /// Confirm Registration
        /// </summary>
        /// <param name="model">an instance of <see>XActionRequest</see> class which provider requirement for action</param>
        /// <returns></returns>
        public async Task ConfirmRegistration (
            XActionRequest model
        ) {
            //
            // Validate Args ...
            await validationProvider
                .GroupValidationBuilder ()
                .AddNotEmpty (
                    model.Lang,
                    model.ActionToken,
                    model.ReturnUrl
                )
                .AddNotNull (model.Device)
                .ValidateGroupAsync ();

            //
            var client = GetRestClient ();

            //
            var request = GetRestRequet (XApiAccountEndpoint.ConfirmRegistration);
            request.AddJsonBody (model);

            //
            var response = await RunRestRequest<object> (
                client,
                request,
                XHttpMethod.POST
            );
        }

        /// <summary>
        /// Request For Mobile Number Change/Confirm 
        /// </summary>
        /// <param name="model">an instance of <see>XActionRequest</see> class which provider requirement for action</param>
        /// <returns>an instance of <see>XActionResponse</see></returns>
        public async Task<XActionResponse> RequestConfirmMobile (XActionRequest model) {
            //
            // Validate Args ...
            await validationProvider
                .GroupValidationBuilder ()
                .AddNotEmpty (
                    model.Lang,
                    model.Password,
                    model.MobileNumber
                )
                .AddNotNull (model.Device)
                .AddMobileNumber (model.MobileNumber)
                .ValidateGroupAsync ();

            //
            // Get UserSelect By Param ...
            var userSelectByParam = GetUserSelectByParam (
                model,
                excludes : new List<XUserSelectBy> {
                    XUserSelectBy.Email,
                    XUserSelectBy.MobileNumber
                });

            //
            var client = GetRestClient ();

            //
            var request = GetRestRequet (XApiAccountEndpoint.RequestConfirmMobile);
            request.AddJsonBody (model);

            //
            var response = await RunRestRequest<XActionResponse> (
                client,
                request,
                XHttpMethod.POST
            );
            return response;
        }

        /// <summary>
        /// Confirm Requested Mobile Number
        /// </summary>
        /// <param name="model">an instance of <see>XActionRequest</see> class which provider requirement for action</param>
        /// <returns>an instance of <see>XActionResponse</see></returns>
        public async Task<XActionResponse> ConfirmMobileNumber (XActionRequest model) {
            //
            // Validate Args ...
            await validationProvider
                .GroupValidationBuilder ()
                .AddNotEmpty (
                    model.Lang,
                    model.ActionToken,
                    model.MobileVerificationCode
                )
                .AddNotNull (model.Device)
                .ValidateGroupAsync ();

            //
            var client = GetRestClient ();

            //
            var request = GetRestRequet (XApiAccountEndpoint.ConfirmMobileNumber);
            request.AddJsonBody (model);

            //
            var response = await RunRestRequest<XActionResponse> (
                client,
                request,
                XHttpMethod.POST
            );
            return response;
        }

        /// <summary>
        /// Request For Email Address Change/Confirm 
        /// </summary>
        /// <param name="model">an instance of <see>XActionRequest</see> class which provider requirement for action</param>
        /// <returns>an instance of <see>XActionResponse</see></returns>
        public async Task<XActionResponse> RequestConfirmEmail (XActionRequest model) {
            //
            // Validate Args ...
            await validationProvider
                .GroupValidationBuilder ()
                .AddNotEmpty (
                    model.Lang,
                    model.Email,
                    model.Password)
                .AddNotNull (model.Device)
                .AddEmailAddress (model.Email)
                .ValidateGroupAsync ();

            //
            // Get UserSelect By Param ...
            var userSelectByParam = GetUserSelectByParam (
                model,
                excludes : new List<XUserSelectBy> {
                    XUserSelectBy.Email,
                    XUserSelectBy.MobileNumber
                });

            //
            var client = GetRestClient ();

            //
            var request = GetRestRequet (XApiAccountEndpoint.RequestConfirmEmail);
            request.AddJsonBody (model);

            //
            var response = await RunRestRequest<XActionResponse> (
                client,
                request,
                XHttpMethod.POST
            );
            return response;
        }

        /// <summary>
        /// Confirm Requested Email Address
        /// </summary>
        /// <param name="model">an instance of <see>XActionRequest</see> class which provider requirement for action</param>
        /// <returns>an instance of <see>XActionResponse</see></returns>
        public async Task<XActionResponse> ConfirmEmailAddress (XActionRequest model) {
            //
            // Validate Args ...
            await validationProvider
                .GroupValidationBuilder ()
                .AddNotEmpty (
                    model.Lang,
                    model.ActionToken,
                    model.EmailVerificationCode
                )
                .AddNotNull (model.Device)
                .ValidateGroupAsync ();

            //
            var client = GetRestClient ();

            //
            var request = GetRestRequet (XApiAccountEndpoint.ConfirmEmailAddress);
            request.AddJsonBody (model);

            //
            var response = await RunRestRequest<XActionResponse> (
                client,
                request,
                XHttpMethod.POST
            );
            return response;
        }

        /// <summary>
        /// Request Reset Password Action
        /// </summary>
        /// <param name="model">an instance of <see>XActionRequest</see> class which provider requirement for action</param>
        /// <returns>an instance of <see>XActionResponse</see></returns>
        public async Task<XActionResponse> RequestResetPassword (XActionRequest model) {
            //
            // Validate Args ...
            await validationProvider
                .GroupValidationBuilder ()
                .AddNotEmpty (
                    model.Lang,
                    model.ReturnUrl)
                .AddNotNull (model.Device)
                .AddUrl (model.ReturnUrl)
                .ValidateGroupAsync ();

            //
            // Get UserSelect By Param ...
            var userSelectByParam = GetUserSelectByParam (
                model,
                excludes : new List<XUserSelectBy> {
                    XUserSelectBy.Email,
                    XUserSelectBy.MobileNumber
                });

            //
            var client = GetRestClient ();

            //
            var request = GetRestRequet (XApiAccountEndpoint.RequestResetPassword);
            request.AddJsonBody (model);

            //
            var response = await RunRestRequest<XActionResponse> (
                client,
                request,
                XHttpMethod.POST
            );
            return response;
        }

        /// <summary>
        /// Reset a User's Password
        /// </summary>
        /// <param name="model">an instance of <see>XActionRequest</see> class which provider requirement for action</param>
        /// <returns></returns>
        public async Task ResetPassword (XActionRequest model) {
            //
            // Validate Args ...
            await validationProvider
                .GroupValidationBuilder ()
                .AddNotNull (model)
                .AddNotEmpty (
                    model.Lang,
                    model.ActionToken,
                    model.NewPassword,
                    model.ReturnUrl)
                .AddNotNull (model.Device)
                .ValidateGroupAsync ();

            //
            var client = GetRestClient ();

            //
            var request = GetRestRequet (XApiAccountEndpoint.ResetPassword);
            request.AddJsonBody (model);

            //
            var response = await RunRestRequest<object> (
                client,
                request,
                XHttpMethod.POST
            );
        }
        #endregion
    }
}