MOBILE_API/JsonRx/Api/CustomerController.cs

using Business.Authentication;
using Business.Mobile;
using Common;
using Common.Model;
using Common.Model.Config;
using Common.Model.CustomerRegister;
using Common.Model.Remit;
using JsonRx.AuthFilter;
using JsonRx.Helper;
using log4net;
using Newtonsoft.Json;
using System;
using System.Linq;
using System.Web;
using System.Web.Http;
using System.Web.Http.ModelBinding;
namespace JsonRx.Api
{
    /// <summary>
    /// </summary>
    [RoutePrefix("api/v1")]
    public class CustomerController : ApiController
    {
        private readonly IMobileServices _requestServices;
        private readonly IAuthenticationBusiness _authenticationBusiness;
        private static readonly ILog Log = LogManager.GetLogger(typeof(CustomerController));

        public CustomerController()
        {
        }

        /// <summary>
        /// </summary>
        /// <param name="requestServices"></param>
        /// <param name="authenticationBusiness"></param>
        public CustomerController(IMobileServices requestServices, IAuthenticationBusiness authenticationBusiness)
        {
            _requestServices = requestServices;
            _authenticationBusiness = authenticationBusiness;
        }

        /// <summary>
        /// </summary>
        /// <param name="registerParam"></param>
        /// <returns></returns>
        [HttpPost]
        [ApplicationLevelAuthentication]
        [Route("mobile/oldUserAccessRequest")]
        public IHttpActionResult OldUserAccessRequest(OldUserAccessRequestModel oldUserAccessRequest)
        {
            LogicalThreadContext.Properties[LoggerProperty.PROCESSID] = Guid.NewGuid();
            LogicalThreadContext.Properties[LoggerProperty.METHODNAME] = "oldUserAccessRequest";
            LogicalThreadContext.Properties[LoggerProperty.CREATEDBY] = oldUserAccessRequest.IdNumber;

            Log.Debug("OldUserAccessRequest | REQUEST : " + JsonConvert.SerializeObject(oldUserAccessRequest));
            Validate(oldUserAccessRequest);
            if (ModelState.IsValid)
            {
                var custRegisterResponse = _requestServices.OldUserAccessRequest(oldUserAccessRequest);
                return Ok(custRegisterResponse);
            }
            return ModelValidationError(ModelState);
        }

        /// <summary>
        /// </summary>
        /// <param name="registerParam"></param>
        /// <returns></returns>
        [HttpPost]
        [ApplicationLevelAuthentication]
        [Route("mobile/oldUserRegister")]
        public IHttpActionResult OldUserRegister(OldUserRegisterModel oldUserRegister)
        {
            LogicalThreadContext.Properties[LoggerProperty.PROCESSID] = Guid.NewGuid();
            LogicalThreadContext.Properties[LoggerProperty.CREATEDBY] = oldUserRegister.UserId;
            LogicalThreadContext.Properties[LoggerProperty.METHODNAME] = "OldUserRegister";

            //CallContext.SetData(Constants.FcmId,registerParam.fcmId);

            Log.Debug("OldUserRegister | REQUEST : " + JsonConvert.SerializeObject(oldUserRegister));
            Validate(oldUserRegister);
            if (ModelState.IsValid)
            {
                var custRegisterResponse = _requestServices.OldUserRegister(oldUserRegister);
                if (custRegisterResponse.ErrorCode == "0")
                {
                    var fcmid = oldUserRegister.fcmId;
                    var lang = Util.getJWTTokenClaim(Request.GetJWTToken(), "language");
                    // Task.Run(() => FcmNotifier.Notify(fcmid, Languages.GetMessage("registration_success", lang), Languages.GetTitle("registration", lang)));
                }
                return Ok(custRegisterResponse);
            }
            return ModelValidationError(ModelState);
        }

        /// <summary>
        /// </summary>
        /// <param name="registerParam"></param>
        /// <returns></returns>
        [HttpPost]
        [ApplicationLevelAuthentication]
        [Route("mobile/newUserRegister")]
        public IHttpActionResult NewUserRegister(NewUserRegisterModel newUserRegister)
        {
            var processid = Guid.NewGuid().ToString();
            LogicalThreadContext.Properties[LoggerProperty.PROCESSID] = processid;
            LogicalThreadContext.Properties[LoggerProperty.CREATEDBY] = newUserRegister.UserId;
            LogicalThreadContext.Properties[LoggerProperty.METHODNAME] = "NewUserRegister";


            Log.Debug("NewUserRegister | REQUEST : " + JsonConvert.SerializeObject(newUserRegister));

            JsonRxResponse res = new JsonRxResponse();
            if (string.IsNullOrEmpty(newUserRegister.UserId))
            {
                res.SetResponse("100", "Email is required!");
                return Ok(res);
            }

            Validate(newUserRegister);
            if (ModelState.IsValid)
            {
               // newUserRegister.phoneOs = Util.GetDeviceType(Request);
                newUserRegister.FullName= newUserRegister.FullName.ToTitleCase(TitleCase.All);
                var custRegisterResponse = _requestServices.NewUserRegister(newUserRegister);
                Log.Debug("NewUserRegister | RESPONSE : " + JsonConvert.SerializeObject(custRegisterResponse));

                return Ok(custRegisterResponse);
            }
            return ModelValidationError(ModelState,"100");
        }

        /// <summary>
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        [TokenAuthentication]
        [Route("mobile/RenewID")]
        public IHttpActionResult RenewID()
        {
            LogicalThreadContext.Properties[LoggerProperty.PROCESSID] = Guid.NewGuid();
            LogicalThreadContext.Properties[LoggerProperty.METHODNAME] = "RenewID";
            LogicalThreadContext.Properties[LoggerProperty.CREATEDBY] = HttpContext.Current.Request["userId"];
            LogicalThreadContext.Properties[LoggerProperty.METHODNAME] = "RenewID";

            //CallContext.SetData(Constants.FcmId, "");

            Log.Debug("RenewID | " + HttpContext.Current.Request["userId"]);
            var kycResponse = _requestServices.RenewID();
            return Ok(kycResponse);
        }



        /// <summary>
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        [TokenAuthentication]
        [Route("mobile/DepositSlip")]
        public IHttpActionResult DepositSlip()
        {

            DepositSlip request = new DepositSlip();
            request.UserId= HttpContext.Current.Request["userId"];
            request.Amount = HttpContext.Current.Request["Amount"];
            request.Remarks = HttpContext.Current.Request["Remarks"];

            LogicalThreadContext.Properties[LoggerProperty.PROCESSID] = Guid.NewGuid();
            LogicalThreadContext.Properties[LoggerProperty.METHODNAME] = "DepositSlip";
            LogicalThreadContext.Properties[LoggerProperty.CREATEDBY] = request.UserId;
           
            Log.Debug("DepositSlip | " + JsonConvert.SerializeObject(request));

            var depositResponse = _requestServices.DepositSlip(request);
            return Ok(depositResponse);
        }


        ///// <summary>
        ///// </summary>
        ///// <param name="search"></param>
        ///// <param name="userId"></param>
        ///// <returns></returns>
        //[HttpPost]
        //[TokenAuthentication]
        //[Route("mobile/DepositSlipHistory/{userId}")]
        //public IHttpActionResult GetDepositSlipHistory(DateFilterParams search, string userId)
        //{
        //    LogicalThreadContext.Properties[LoggerProperty.PROCESSID] = Guid.NewGuid();
        //    LogicalThreadContext.Properties[LoggerProperty.CREATEDBY] = userId;
        //    LogicalThreadContext.Properties[LoggerProperty.METHODNAME] = "GetDepositSlipHistory";
        //    Log.Debug("GetDepositSlipHistory | REQUEST : " + userId);
        //    var tranHistoryResponse = _requestServices.GetTransactionHistory(search, userId);
        //    return Ok(tranHistoryResponse);
        //}

        /// <summary>
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        [TokenAuthentication]
        [Route("mobile/RegisterKyc")]
        public IHttpActionResult RegisterKyc()
        {
            LogicalThreadContext.Properties[LoggerProperty.PROCESSID] = Guid.NewGuid();
            LogicalThreadContext.Properties[LoggerProperty.METHODNAME] = "RegisterKyc";
            LogicalThreadContext.Properties[LoggerProperty.CREATEDBY] = HttpContext.Current.Request["userId"];
            LogicalThreadContext.Properties[LoggerProperty.IPADDRESS] =  HttpContext.Current.Request["TrustDocId"] != null ? HttpContext.Current.Request["TrustDocId"] : "";

            //Log.Debug("RegisterKyc | REQUEST : " + HttpContext.Current.Request["userId"]);
            //var fcmid = Util.getJWTTokenClaim(Request.GetJWTToken(), "ClientFcmId");
            var kycResponse = _requestServices.RegisterKYC(Util.GetDeviceType(Request));
            return Ok(kycResponse);
        }

        /// <summary>
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        [TokenAuthentication]
        [Route("mobile/RegisterKycExistingCustomer")]
        public IHttpActionResult RegisterKycExistingCustomer()
        {
            LogicalThreadContext.Properties[LoggerProperty.PROCESSID] = Guid.NewGuid();
            LogicalThreadContext.Properties[LoggerProperty.METHODNAME] = "RegisterKyc";
            LogicalThreadContext.Properties[LoggerProperty.CREATEDBY] = HttpContext.Current.Request["userId"];
            LogicalThreadContext.Properties[LoggerProperty.METHODNAME] = "RegisterKycExistingCustomer";

            //CallContext.SetData(Constants.FcmId, "");

            Log.Debug("RegisterKycExistingCustomer | REQUEST : " + HttpContext.Current.Request["userId"]);
            var kycResponse = _requestServices.RegisterKycExistingCustomer();
            return Ok(kycResponse);
        }

        /// <summary>
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        [TokenAuthentication]
        [Route("mobile/changeTxnPin")]
        public IHttpActionResult ChangeTxnPin(ChangeTxnPinModel changeTxnPin)
        {

            LogicalThreadContext.Properties[LoggerProperty.PROCESSID] = Guid.NewGuid();
            LogicalThreadContext.Properties[LoggerProperty.CREATEDBY] = changeTxnPin.UserId;
            LogicalThreadContext.Properties[LoggerProperty.METHODNAME] = "ChangeTxnPin";

            //CallContext.SetData(Constants.FcmId, "");

            Log.Debug("ChangeTxnPin | REQUEST : " + JsonConvert.SerializeObject(changeTxnPin));
            var kycResponse = _requestServices.ChangeTxnPin(changeTxnPin);
            return Ok(kycResponse);
        }

        /// <summary>
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        [TokenAuthentication]
        [Route("mobile/changePasswordAndTxnPin")]
        public IHttpActionResult ChangePasswordAndTxnPin(ChangePasswordAndTxnPinModel changePasswordAndTxnPin)
        {
            LogicalThreadContext.Properties[LoggerProperty.PROCESSID] = Guid.NewGuid();
            LogicalThreadContext.Properties[LoggerProperty.CREATEDBY] = changePasswordAndTxnPin.UserId;
            LogicalThreadContext.Properties[LoggerProperty.METHODNAME] = "ChangePasswordAndTxnPin";

            //CallContext.SetData(Constants.FcmId, "");

            Log.Debug("ChangePasswordAndTxnPin | REQUEST : " + JsonConvert.SerializeObject(changePasswordAndTxnPin));
            var kycResponse = _requestServices.ChangePasswordAndTxnPin(changePasswordAndTxnPin);
            return Ok(kycResponse);
        }

        /// <summary>
        /// </summary>
        /// <param name="user"></param>
        /// <returns></returns>
        [HttpPost]
        [TokenAuthentication]
        [Route("mobile/CustomerProfile")]
        public IHttpActionResult RefreshCustomerInformation(UserModel user)
        {
            LogicalThreadContext.Properties[LoggerProperty.PROCESSID] = Guid.NewGuid();
            LogicalThreadContext.Properties[LoggerProperty.CREATEDBY] = user.UserId;
            LogicalThreadContext.Properties[LoggerProperty.METHODNAME] = "RefreshCustomerInformation";
            LogicalThreadContext.Properties[LoggerProperty.IPADDRESS] = Request.GetClientIpAddress();

            Log.Debug("RefreshCustomerInformation | REQUEST : " + JsonConvert.SerializeObject(user));

            JsonRxResponse custResponse = new JsonRxResponse();
            if (user == null)
            {
                user = new UserModel();
            }
            if (string.IsNullOrEmpty(user.UserId))
            {
                custResponse.ErrorCode = "1";
                custResponse.Msg = "UserId is missing.";
                return Ok(custResponse);
            }
            custResponse = _requestServices.RefreshCustomerInformation(user);
            return Ok(custResponse);
        }

        /// <summary>
        /// </summary>
        /// <param name="customer"></param>
        /// <param name="search"></param>
        /// <returns></returns>
        [HttpGet]
        [TokenAuthentication]
        [Route("mobile/{customer}/receivers")]
        public IHttpActionResult GetReceiversByCustomer(string customer, [FromUri] string search)
        {
            LogicalThreadContext.Properties[LoggerProperty.PROCESSID] = Guid.NewGuid();
            LogicalThreadContext.Properties[LoggerProperty.CREATEDBY] = customer;
            LogicalThreadContext.Properties[LoggerProperty.METHODNAME] = "GetReceiversByCustomer";
            Log.Debug("GetReceiversByCustomer | REQUEST : " + customer);
            Log.Debug("GetReceiversByCustomer | REQUEST : " + customer);
            var customerId = Util.GetCustomerId(Request);
            var lsReceivers = _requestServices.GetReceiversByCustomer(customer, customerId, search);

            return Ok(lsReceivers);
        }

        [HttpPost]
        [TokenAuthentication]
        [Route("mobile/ChangeSettings")]
        public IHttpActionResult ChangeSettings(ChangeSettingModel changeSettings)
        {
            LogicalThreadContext.Properties[LoggerProperty.PROCESSID] = Guid.NewGuid();
            LogicalThreadContext.Properties[LoggerProperty.CREATEDBY] = changeSettings.UserId;
            LogicalThreadContext.Properties[LoggerProperty.METHODNAME] = "ChangeSettings";

            //CallContext.SetData(Constants.FcmId, "");
            Log.Debug("ChangeSettings | REQUEST : " + JsonConvert.SerializeObject(changeSettings));

            ModelState.Clear();

            // changeSettings.uuid = Util.GetUuid(Request);
            string token = Guid.NewGuid().ToString();
            changeSettings.guid = token;

            int SettingTypeInt;
            int.TryParse(changeSettings.SettingType.ToString(), out SettingTypeInt);
            JsonRxResponse res = new JsonRxResponse();
            if (Enum.IsDefined(typeof(SettingType), changeSettings.SettingType)
             || Enum.IsDefined(typeof(SettingType), SettingTypeInt))
            {

                if (changeSettings.SettingType == SettingType.FINGER_PRINT_LOGIN)
                {
                    if (changeSettings.Flag && string.IsNullOrEmpty(changeSettings.Password))
                    {
                        res.ErrorCode = "1";
                        res.Msg = "Password is required.";
                        return Ok(res);
                    }

                    res = _requestServices.ChangeSettings(changeSettings);
                }
            }
            else
            {
                res.ErrorCode = "1";
                res.Msg = "SettingType is Invalid.";

                Log.Info("ChangeSettings |  RESPONSE : " + JsonConvert.SerializeObject(res));
                return Ok(res);
            }


            return Ok(res);
        }
        /// <summary>
        /// </summary>
        /// <param name="modelState"></param>
        /// <returns></returns>
        protected IHttpActionResult ModelValidationError(ModelStateDictionary modelState, string error="")
        {
            var modelErrors = modelState.Select(x => x.Value.Errors)
                       .Where(y => y.Count > 0)
                       .First()[0].ErrorMessage;
            JsonRxResponse jsonRx = new JsonRxResponse()
            {
                ErrorCode = error??"1",
                Msg = string.IsNullOrEmpty(modelErrors) ? "It seems like incorrect Json input(s)." : modelErrors,
                Data = ""
            };
            return Ok(jsonRx);
        }

        /// <summary>
        /// </summary>
        /// <param name="referralCode"></param>
        /// <returns></returns>
        [HttpPost]
        [ApplicationLevelAuthentication]
        [Route("mobile/validateReferralCode")]
        public IHttpActionResult ValidateReferralCode(validateReferralCodeRequest request)
        {
            LogicalThreadContext.Properties[LoggerProperty.CREATEDBY] = request.referralCode;
            LogicalThreadContext.Properties[LoggerProperty.METHODNAME] = "ValidateReferralCode";
            LogicalThreadContext.Properties[LoggerProperty.IPADDRESS] = Request.GetClientIpAddress();
            Log.Debug("ValidateReferralCode | REQUEST : " + JsonConvert.SerializeObject(request));
            if (ModelState.IsValid)
            {
                var response = _requestServices.ValidateReferralCode(request.referralCode);
                return Ok(response);
            }
            return ModelValidationError(ModelState);
        }
    }
}