Luckycall/LuckyCallWebCore/LuckyCallWebCore/Controllers/SubscriberController.cs

using log4net;
using LuckyCallWebCore.Source;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Configuration;
using ServiceAPI;
using System;
using LuckyCallWebCore.Extensions;
using LuckyCallWebCore.Models;
using Microsoft.Extensions.Primitives;
using Newtonsoft.Json;
using System.ServiceModel;
using System.ServiceModel.Channels;
using System.Threading.Tasks;

namespace LuckyCallWebCore.Controllers
{
    public class SubscriberController : BaseController
    {
        private static ILog log = LogManager.GetLogger("SubscriberController");


        ServiceAPI.WsLuckyCallClient wsClient = new ServiceAPI.WsLuckyCallClient();

        [HttpPost]
        [ValidateAntiForgeryToken]
        public JsonResult Subscribe(String msisdn, String packName)
        {
            if (msisdn == null || msisdn.Trim() == "")
            {
                msisdn = HttpContext.Session.GetString("msisdn");
            }
            if (msisdn != "" && msisdn != null)
            {
                msisdn = validateMsisdn(msisdn);
                SetWsClient(ref wsClient, msisdn);

                //ServiceAPI.response subInfo = wsClient.wsGetSubInfo(wsUser, wsPassword, msisdn);
                ServiceAPI.response res = null;
                res = wsClient.wsRegisterSubOtp(wsUser, wsPassword, msisdn, packName);

                if (res.errorCode == "0")
                {
                    // success
                }
                else if (res.errorCode == "100")
                {
                    // need confirm
                    RequestTemp reqTemp = new RequestTemp();
                    reqTemp.packName = packName;
                    reqTemp.requestId = res.resultCode;
                    reqTemp.msisdn = msisdn;
                    Session["reqTemp"] = reqTemp;
                }
                return Json(new
                {
                    error = res.errorCode,
                    content = res.content,
                    msisdn = msisdn.Substring(3)
                });
            }
            else
            {
                return Json(new
                {
                    error = "-1",
                    content = Lang.InvalidMsisdn
                });
            }
        }

        [ValidateAntiForgeryToken]
        public JsonResult SubscribeConfirm(String otp)
        {
            RequestTemp reqTemp = Session["reqTemp"] as RequestTemp;
            if (reqTemp == null)
            {
                return Json(new
                {
                    error = "-1",
                    content = "Timeout",
                    href = "/Home/Index"
                });
            }


            String msisdn = reqTemp.msisdn;
            if (msisdn != "" && msisdn != null)
            {
                CommonUtils.SetWsClient(ref wsClient, Session.SessionID);

                //ServiceAPI.response subInfo = wsClient.wsGetSubInfo(wsUser, wsPassword, msisdn);
                ServiceAPI.response res = null;

                String channel = ConfigurationManager.AppSettings["reddemChannel"];
                res = wsClient.wsRegisterSubConfirm(wsUser, wsPassword, msisdn, reqTemp.packName, otp);

                if (res.errorCode == "0")
                {
                    // login success --> store session
                    Session["msisdn"] = msisdn;
                    Session["account"] = wsClient.wsGetSubInfo(wsUser, wsPassword, msisdn);
                }

                return Json(new
                {
                    error = res.errorCode,
                    content = res.content,
                    msisdn = msisdn.Substring(3)
                });
            }
            else
            {
                return Json(new
                {
                    error = "-1",
                    content = "Timeout"
                });
            }
        }


        [HttpPost]
        [ValidateAntiForgeryToken]
        public JsonResult LoginAction(String phoneNumber, string password, string captcharesponse)
        {

            String msisdn = CommonUtils.validateMsisdn(phoneNumber);

            CheckSessionRes checkSession = CheckSessionValid(ActionSession.Login);
            if (checkSession.errorCode != "0")
            {
                return Json(new
                {
                    error = checkSession.errorCode,
                    content = checkSession.content,
                    msisdn = msisdn.Substring(3)
                });
            }

            if (msisdn != "")
            {
                ServiceAPI.response subInfo = null;
                CommonUtils.SetWsClient(ref wsClient, Session.SessionID);
                ServiceAPI.response res = wsClient.wsLogin(wsUser, wsPassword, password, msisdn);

                if (res.errorCode == "0")
                {
                    // login success --> store session
                    Session["msisdn"] = msisdn;
                    subInfo = wsClient.wsGetSubInfo(wsUser, wsPassword, msisdn);
                    Session["account"] = subInfo;
                    LoginSuccessAction();
                }
                else
                {
                    LoginFailAction();
                }

                if (subInfo != null)
                {
                    return Json(new
                    {
                        error = res.errorCode,
                        content = res.content,
                        msisdn = msisdn.Substring(3)
                    });
                }
                else
                {
                    return Json(new
                    {
                        error = res.errorCode,
                        content = res.content,
                        msisdn = msisdn.Substring(3)
                    });
                }
            }
            else
            {
                return Json(new
                {
                    error = "-1",
                    content = Lang.InvalidMsisdn
                });
            }
        }

        [ValidateAntiForgeryToken]
        public JsonResult SignupAction(String phoneNumber, string captcharesponse)
        {
            //if (Check(captcharesponse) == false)
            //{
            //    return Json(new
            //    {
            //        error = "16",
            //        content = Lang.CaptchaInvalid
            //    });
            //}

            CheckSessionRes checkSession = CheckSessionValid(ActionSession.SignUp);
            if (checkSession.errorCode != "0")
            {
                return Json(new
                {
                    error = checkSession.errorCode,
                    content = checkSession.content
                });
            }

            String msisdn = CommonUtils.validateMsisdn(phoneNumber);
            if (msisdn != "")
            {
                CommonUtils.SetWsClient(ref wsClient, Session.SessionID);
                ServiceAPI.response res = wsClient.wsCreateAccount(wsUser, wsPassword, "", msisdn, "1");

                if (res.errorCode == "0")
                {
                    // signup success --> store session
                    SetLastSignUp();

                    Session["msisdn"] = msisdn;
                    ViewBag.msisdn = msisdn;
                    CommonUtils.SetWsClient(ref wsClient, Session.SessionID);
                    ServiceAPI.response subInfo = wsClient.wsGetSubInfo(wsUser, wsPassword, msisdn);
                    Session["account"] = subInfo;
                }

                return Json(new
                {
                    error = res.errorCode,
                    content = res.content,
                    msisdn = msisdn.Substring(3)
                });
            }
            else
            {
                return Json(new
                {
                    error = "-1",
                    content = Lang.InvalidMsisdn
                });
            }
        }


        [ValidateAntiForgeryToken]
        public JsonResult ResetPassword(String phoneNumber, string captcharesponse)
        {
            //if (Check(captcharesponse) == false)
            //{
            //    return Json(new
            //    {
            //        error = "16",
            //        content = Lang.CaptchaInvalid
            //    });
            //}
            CheckSessionRes checkSession = CheckSessionValid(ActionSession.Resetpass);
            if (checkSession.errorCode != "0")
            {
                return Json(new
                {
                    error = checkSession.errorCode,
                    content = checkSession.content
                });
            }

            String wsUser = ConfigurationManager.AppSettings["wsUser"];
            String wsPassword = ConfigurationManager.AppSettings["wsPassword"];

            String msisdn = CommonUtils.validateMsisdn(phoneNumber);
            if (msisdn != "")
            {
                ServiceAPI.WsMillionClient wsClient = new ServiceAPI.WsMillionClient();
                CommonUtils.SetWsClient(ref wsClient, Session.SessionID);
                ServiceAPI.response res = wsClient.wsResetPassword(wsUser, wsPassword, msisdn);

                SetLastResetPass();
                return Json(new
                {
                    error = res.errorCode,
                    content = res.content
                });
            }
            else
            {
                return Json(new
                {
                    error = "-1",
                    content = Lang.InvalidMsisdn
                });
            }
        }

        [HttpPost]
        public JsonResult CancelService()
        {
            String msisdn = Session["msisdn"] as String;
            if (msisdn != "" && msisdn != null)
            {
                wsClient.Endpoint.Address = GetWsEndpoint();
                var res = wsClient.wsCancelService(wsUser, wsPassword, msisdn);

                if (res.errorCode == "0")
                {
                    Session["account"] = wsClient.wsGetSubInfo(wsUser, wsPassword, msisdn);
                }
                return Json(new
                {
                    error = res.errorCode,
                    content = res.content,
                    msisdn = msisdn.Substring(3)
                });
            }
            else
            {
                return Json(new
                {
                    error = "-1"
                });
            }
        }


        [HttpPost]
        public JsonResult BuyTurnOtp(String numTurn)
        {
            String msisdn = Session["msisdn"] as String;
            if (msisdn != "" && msisdn != null)
            {

                log.Info("BuyTurn " + msisdn + ", numTurn: " + numTurn);

                wsClient.Endpoint.Address = GetWsEndpoint();
                response res = wsClient.wsBuyTurnOtp(wsUser, wsPassword, msisdn, numTurn);

                return Json(new
                {
                    error = res.errorCode,
                    content = res.content,
                    msisdn = msisdn.Substring(3),
                    numTurn = numTurn
                });
            }
            else
            {
                return Json(new
                {
                    error = "-1"
                });
            }
        }

        [HttpPost]
        public JsonResult BuyTurnConfirm(String otp, String numTurn)
        {
            String msisdn = Session["msisdn"] as String;
            if (msisdn != "" && msisdn != null)
            {
                log.Info("BuyTurnConfirm " + msisdn + ", numTurn: " + numTurn);

                wsClient.Endpoint.Address = GetWsEndpoint();

                response res = wsClient.wsBuyTurn(wsUser, wsPassword, msisdn, numTurn, otp);
                log.Info("BuyTurnConfirm " + msisdn + ": " + res.errorCode);

                if (res.errorCode == "0")
                {
                    Session["account"] = wsClient.wsGetSubInfo(wsUser, wsPassword, msisdn);
                }

                return Json(new
                {
                    error = res.errorCode,
                    content = res.content,
                    msisdn = msisdn.Substring(3)
                });
            }
            else
            {
                return Json(new
                {
                    error = "-1"
                });
            }
        }



        public ActionResult Login()
        {
            return View();
        }

        public RedirectResult Logout()
        {
            Session.Clear();
            return Redirect("/Home?detecting=0");
        }

        private bool Check(string response)
        {
            //string Response = HttpContext.Current.Request.QueryString["g-recaptcha-response"];//Getting Response String Append to Post Method
            bool Valid = false;
            //Request to Google Server
            HttpWebRequest req = (HttpWebRequest)WebRequest.Create
            (" https://www.google.com/recaptcha/api/siteverify?secret=" + CommonUtils.CaptchaSecretKey + "&response=" + response);
            try
            {
                //Google recaptcha Response
                using (WebResponse wResponse = req.GetResponse())
                {

                    using (StreamReader readStream = new StreamReader(wResponse.GetResponseStream()))
                    {
                        string jsonResponse = readStream.ReadToEnd();

                        JavaScriptSerializer js = new JavaScriptSerializer();
                        MyObject data = js.Deserialize<MyObject>(jsonResponse);// Deserialize Json

                        Valid = Convert.ToBoolean(data.success);
                    }
                }

                return Valid;
            }
            catch (WebException ex)
            {
                throw ex;
            }
        }

        public class MyObject
        {
            public string success { get; set; }
        }
    }
}