Luckycall/LuckyCallWebCore/LuckyCallWebCore/Controllers/HomeController.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 System.Threading.Tasks;
using Mzb_LuckyCall.Resources;
using System.ServiceModel;
using System.ServiceModel.Channels;

namespace LuckyCallWebCore.Controllers
{
    public class HomeController : BaseController
    {

        private ILog log = LogManager.GetLogger("HomeController");

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

        public HomeController(IConfiguration _configuration, IWebHostEnvironment hostEnvironment) : base(_configuration, hostEnvironment)
        {
            // init 
        }

        public async Task<IActionResult> Index()
        {
            var account = await IdentifyMsisdn();

            if (account == "NOT_FOUND")
            {
                //return Redirect("/Home/Guide");
                return Redirect("/Home/Login");
            }
            if (account == null)
            {
                //return Redirect("/Home/NotSupport");
                return Redirect("/Home/Login");
            }
            ReloadUserInfo(account);

            SetWsClient(ref wsClient, account);
            using (new OperationContextScope(wsClient.InnerChannel))
            {
                // Add a HTTP Header to an outgoing request
                HttpRequestMessageProperty requestMessage = new HttpRequestMessageProperty();
                requestMessage.Headers["lang"] = getCurrentLang();
                OperationContext.Current.OutgoingMessageProperties[HttpRequestMessageProperty.Name] = requestMessage;
                response res = wsClient.wsGetListWinner(wsUser, wsPassword, null, "3", "1", "1", "-1", "-1");
                if (res.listWinner != null && res.listWinner.Length > 0)
                {
                    var lastMonthWinner = res.listWinner[0];
                    lastMonthWinner.msisdn = HiddenMsisdn(lastMonthWinner.msisdn);
                    HttpContext.Session.SetComplexData("lastMonthWinner", lastMonthWinner);
                }
            }
            return await Task.Run(() => View());

            // return View();
        }

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

        public IActionResult Logout()
        {
            try
            {
                ClearCache();
                //return Redirect("mytel://home");
                return Redirect("/Home/Login");
            }
            catch (Exception ex)
            {
                log.Error("Exception " + ex);
                return Redirect("/Home/Error");
            }
        }


        [HttpPost]
        public IActionResult LogoutAction()
        {
            ClearCache();
            return Json(new
            {
                error = "0"
            });
        }

        public IActionResult NotSupport()
        {
            try
            {
                //ClearCache();
                return View();
            }
            catch (Exception ex)
            {
                log.Error("Exception " + ex);
                return Redirect("/Home/Error");
            }
        }

        private void ReloadUserInfo(String username)
        {
            // store session
            UserInfo userInfo = new UserInfo();
            userInfo.msisdn = username;
            userInfo.username = username;
            //userInfo.remain_spin = 3;

            SetWsClient(ref wsClient, username);

            // get sub info
            using (new OperationContextScope(wsClient.InnerChannel))
            {
                // Add a HTTP Header to an outgoing request
                HttpRequestMessageProperty requestMessage = new HttpRequestMessageProperty();
                requestMessage.Headers["lang"] = getCurrentLang();
                OperationContext.Current.OutgoingMessageProperties[HttpRequestMessageProperty.Name] = requestMessage;


                response resSub = wsClient.wsGetSubInfo(wsUser, wsPassword, username);
                userInfo.spinInfo = resSub.spinResult;
                userInfo.total_spin = userInfo.spinInfo.totalSpin;
                //
                if (resSub.listRegInfo != null && resSub.listRegInfo.Length > 0)
                {
                    userInfo.regInfo = resSub.listRegInfo[0];
                    userInfo.total_spin = userInfo.total_spin + userInfo.regInfo.remainQuestion;
                }
                // coin
                userInfo.userCoin = resSub.userCoin;

                // store
                HttpContext.Session.SetComplexData("userInfo", userInfo);
            }
        }

        public IActionResult LuckyDraw()
        {
            UserInfo userInfo = HttpContext.Session.GetComplexData<UserInfo>("userInfo");
            if (!CheckAuthToken() || userInfo == null)
            {
                return Redirect("mytel://home");
            }

            //if (userInfo.remain_spin == 0)
            //{
            //    return Redirect("/Home/Prize");
            //}
            return View();
        }

        public async Task<IActionResult> UserPrize(String page)
        {
            String account = HttpContext.Session.GetString("account");
            UserInfo userInfo = HttpContext.Session.GetComplexData<UserInfo>("userInfo");
            if (!CheckAuthToken() || userInfo == null)
            {
                return Redirect("mytel://home");
            }

            // get user prize
            page = page ?? "1";
            String rowOnPage = configuration["pageSize"];


            SetWsClient(ref wsClient, account);
            using (new OperationContextScope(wsClient.InnerChannel))
            {
                // Add a HTTP Header to an outgoing request
                HttpRequestMessageProperty requestMessage = new HttpRequestMessageProperty();
                requestMessage.Headers["lang"] = getCurrentLang();
                OperationContext.Current.OutgoingMessageProperties[HttpRequestMessageProperty.Name] = requestMessage;
                response res = wsClient.wsGetListWinner(wsUser, wsPassword, userInfo.msisdn, "-1", page, rowOnPage, "-1", "1");

                // model
                LuckyWheelModel model = new LuckyWheelModel();
                model.page = page;
                model.pageSize = rowOnPage;
                model.totalPage = res.totalPage;
                model.listWinner = res.listWinner;
                return View(model);
            }
        }


        public async Task<IActionResult> WinnerList()
        {
            String account = HttpContext.Session.GetString("account");
            UserInfo userInfo = HttpContext.Session.GetComplexData<UserInfo>("userInfo");
            if (!CheckAuthToken() || userInfo == null)
            {
                return Redirect("mytel://home");
            }

            return await Task.Run(() => View());
        }

        [HttpPost]
        [ValidateAntiForgeryToken]
        public async Task<IActionResult> GetWinner(String page, String period)
        {
            String account = HttpContext.Session.GetString("account");
            UserInfo userInfo = HttpContext.Session.GetComplexData<UserInfo>("userInfo");
            if (!CheckAuthToken() || userInfo == null)
            {
                return Json(new
                {
                    error = "-1",
                    content = "Timeout",
                    href = "mytel://home"
                });
            }

            // get user prize
            page = page ?? "1";
            String rowOnPage = configuration["pageSize"];

            SetWsClient(ref wsClient, account);
            using (new OperationContextScope(wsClient.InnerChannel))
            {
                // Add a HTTP Header to an outgoing request
                HttpRequestMessageProperty requestMessage = new HttpRequestMessageProperty();
                requestMessage.Headers["lang"] = getCurrentLang();
                OperationContext.Current.OutgoingMessageProperties[HttpRequestMessageProperty.Name] = requestMessage;
                response res = wsClient.wsGetListWinner(wsUser, wsPassword, null, period, page, rowOnPage, "-1", "-1");
                if (res.listWinner != null)
                {
                    for (int i = 0; i < res.listWinner.Length; i++)
                    {
                        res.listWinner[i].msisdn = HiddenMsisdn(res.listWinner[i].msisdn);
                    }
                }
                // model
                LuckyWheelModel model = new LuckyWheelModel();
                model.page = page;
                model.pageSize = rowOnPage;
                model.totalPage = res.totalPage;
                model.listWinner = res.listWinner;
                return PartialView("../Partial/_Winner", model);
            }
        }

        [HttpPost]
        [ValidateAntiForgeryToken]
        public IActionResult GetTopCoin()
        {
            String account = HttpContext.Session.GetString("account");
            UserInfo userInfo = HttpContext.Session.GetComplexData<UserInfo>("userInfo");
            if (!CheckAuthToken() || userInfo == null)
            {
                return Json(new
                {
                    error = "-1",
                    content = "Timeout",
                    href = "mytel://home"
                });
            }

            // get user prize
            String rowOnPage = configuration["pageSize"];
            String size = "30";

            SetWsClient(ref wsClient, account);
            using (new OperationContextScope(wsClient.InnerChannel))
            {
                // Add a HTTP Header to an outgoing request
                HttpRequestMessageProperty requestMessage = new HttpRequestMessageProperty();
                requestMessage.Headers["lang"] = getCurrentLang();
                OperationContext.Current.OutgoingMessageProperties[HttpRequestMessageProperty.Name] = requestMessage;
                //
                response res = wsClient.wsGetTopCoin(wsUser, wsPassword, size);

                // model
                LuckyWheelModel model = new LuckyWheelModel();
                model.page = "1";
                model.pageSize = rowOnPage;
                if (res.listUserCoin != null)
                {
                    model.totalPage = Convert.ToInt32(Math.Ceiling(res.listUserCoin.Length / decimal.Parse(rowOnPage)));
                    for (int i = 0; i < res.listUserCoin.Length; i++)
                    {
                        res.listUserCoin[i].msisdn = HiddenMsisdn(res.listUserCoin[i].msisdn);
                    }
                }
                model.listUserCoin = res.listUserCoin;


                response resRank = wsClient.wsGetUserRank(wsUser, wsPassword, userInfo.msisdn);
                model.userCoin = resRank.userCoin;
                return PartialView("../Partial/_TopCoin", model);
            }
        }

        public IActionResult Guide()
        {
            string currentLang = getCurrentLang();
            return View("Guide_" + currentLang);
        }


        public IActionResult Error()
        {
            return View();
        }



        [HttpPost]
        [ValidateAntiForgeryToken]
        public async Task<JsonResult> SpinAction()
        {

            String account = HttpContext.Session.GetString("account");
            UserInfo userInfo = HttpContext.Session.GetComplexData<UserInfo>("userInfo");
            if (!CheckAuthToken() || userInfo == null)
            {
                return Json(new
                {
                    error = "-1",
                    content = "Timeout",
                    href = "mytel://home"
                });
            }
            if (userInfo.total_spin > 0)
            {
                SetWsClient(ref wsClient, account);
                using (new OperationContextScope(wsClient.InnerChannel))
                {
                    // Add a HTTP Header to an outgoing request
                    HttpRequestMessageProperty requestMessage = new HttpRequestMessageProperty();
                    requestMessage.Headers["lang"] = getCurrentLang();
                    OperationContext.Current.OutgoingMessageProperties[HttpRequestMessageProperty.Name] = requestMessage;
                    response res = wsClient.wsDoSpin(wsUser, wsPassword, userInfo.msisdn, BaseController.channel);

                    if (res.errorCode == "0")
                    {
                        // check prize add spin
                        spinResultObj spinResult = res.spinResult;
                        userInfo.spinInfo = spinResult;
                        prizeObj prizeObj = MapPrize()[spinResult.prizeId];
                        HttpContext.Session.SetComplexData("userInfo", userInfo);

                        return Json(new
                        {
                            error = "0",
                            content = res.content,
                            prize = prizeObj,
                            remainSpin = userInfo.spinInfo.remainSpin,
                            totalSpin = userInfo.spinInfo.totalSpin,
                            usedSpin = userInfo.spinInfo.usedSpin,
                            totalCoin = userInfo.spinInfo.totalCoin,
                            lastAction = prizeObj.actionCode
                        });
                    }
                    else
                    {
                        return Json(new
                        {
                            error = res.errorCode,
                            content = res.content
                        });
                    }
                }
            }
            else
            {
                return Json(new
                {
                    error = "1",
                    content = "Out of spin"
                });
            }
        }

        [HttpPost]
        [ValidateAntiForgeryToken]
        public async Task<JsonResult> RegisterOtp(String packageName)
        {
            String account = HttpContext.Session.GetString("account");
            UserInfo userInfo = HttpContext.Session.GetComplexData<UserInfo>("userInfo");
            if (!CheckAuthToken() || userInfo == null)
            {
                return Json(new
                {
                    error = "-1",
                    content = "Timeout",
                    href = "mytel://home"
                });
            }

            SetWsClient(ref wsClient, account);
            using (new OperationContextScope(wsClient.InnerChannel))
            {
                // Add a HTTP Header to an outgoing request
                HttpRequestMessageProperty requestMessage = new HttpRequestMessageProperty();
                requestMessage.Headers["lang"] = getCurrentLang();
                OperationContext.Current.OutgoingMessageProperties[HttpRequestMessageProperty.Name] = requestMessage;
                response res = wsClient.wsRegisterSubOtp(wsUser, wsPassword, userInfo.msisdn, packageName, BaseController.channel);

                if (res.errorCode == "0" || res.errorCode == "100")
                {
                    RequestOtp requestOtp = new RequestOtp();
                    requestOtp.msisdn = userInfo.msisdn;
                    requestOtp.packageName = packageName;
                    requestOtp.requestId = res.resultCode;
                    HttpContext.Session.SetComplexData("requestOtp", requestOtp);
                    return Json(new
                    {
                        error = res.errorCode,
                        content = res.content
                    });
                }
                else
                {
                    return Json(new
                    {
                        error = res.errorCode,
                        content = res.content
                    });
                }
            }

        }

        [HttpPost]
        [ValidateAntiForgeryToken]
        public async Task<JsonResult> RegisterConfirm(String otp)
        {
            String account = HttpContext.Session.GetString("account");
            UserInfo userInfo = HttpContext.Session.GetComplexData<UserInfo>("userInfo");
            RequestOtp requestOtp = HttpContext.Session.GetComplexData<RequestOtp>("requestOtp");
            if (!CheckAuthToken() || userInfo == null)
            {
                return Json(new
                {
                    error = "-1",
                    content = "Timeout",
                    href = "mytel://home"
                });
            }

            SetWsClient(ref wsClient, account);
            using (new OperationContextScope(wsClient.InnerChannel))
            {
                // Add a HTTP Header to an outgoing request
                HttpRequestMessageProperty requestMessage = new HttpRequestMessageProperty();
                requestMessage.Headers["lang"] = getCurrentLang();
                OperationContext.Current.OutgoingMessageProperties[HttpRequestMessageProperty.Name] = requestMessage;
                response res = wsClient.wsRegisterSubConfirm(wsUser, wsPassword, userInfo.msisdn, requestOtp.packageName, requestOtp.requestId, otp, BaseController.channel);

                if (res.errorCode == "0")
                {
                    return Json(new
                    {
                        error = "0",
                        content = res.content
                    });
                }
                else
                {
                    return Json(new
                    {
                        error = res.errorCode,
                        content = res.content
                    });
                }
            }
        }

        [HttpPost]
        [ValidateAntiForgeryToken]
        public async Task<JsonResult> CancelConfirm(String packageName)
        {
            String account = HttpContext.Session.GetString("account");
            UserInfo userInfo = HttpContext.Session.GetComplexData<UserInfo>("userInfo");
            if (!CheckAuthToken() || userInfo == null)
            {
                return Json(new
                {
                    error = "-1",
                    content = "Timeout",
                    href = "mytel://home"
                });
            }

            SetWsClient(ref wsClient, account);
            using (new OperationContextScope(wsClient.InnerChannel))
            {
                // Add a HTTP Header to an outgoing request
                HttpRequestMessageProperty requestMessage = new HttpRequestMessageProperty();
                requestMessage.Headers["lang"] = getCurrentLang();
                OperationContext.Current.OutgoingMessageProperties[HttpRequestMessageProperty.Name] = requestMessage;
                response res = wsClient.wsCancelSub(wsUser, wsPassword, account, packageName, channel);

                if (res.errorCode == "0")
                {
                    return Json(new
                    {
                        error = res.errorCode,
                        content = res.content
                    });
                }
                else
                {
                    return Json(new
                    {
                        error = res.errorCode,
                        content = res.content
                    });
                }
            }

        }


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

            String msisdn = 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;
                SetWsClient(ref wsClient, msisdn);
                using (new OperationContextScope(wsClient.InnerChannel))
                {
                    // Add a HTTP Header to an outgoing request
                    HttpRequestMessageProperty requestMessage = new HttpRequestMessageProperty();
                    requestMessage.Headers["lang"] = getCurrentLang();
                    OperationContext.Current.OutgoingMessageProperties[HttpRequestMessageProperty.Name] = requestMessage;
                    ServiceAPI.response res = wsClient.wsLogin(wsUser, wsPassword, password, msisdn);

                    if (res.errorCode == "0")
                    {
                        // login success --> store session
                        CreateAuthToken(msisdn, null);
                        ReloadUserInfo(msisdn);
                        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.LoginFailed
                });
            }
        }

        [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 = validateMsisdn(phoneNumber);
            if (msisdn != "")
            {
                SetWsClient(ref wsClient, msisdn);
                using (new OperationContextScope(wsClient.InnerChannel))
                {
                    // Add a HTTP Header to an outgoing request
                    HttpRequestMessageProperty requestMessage = new HttpRequestMessageProperty();
                    requestMessage.Headers["lang"] = getCurrentLang();
                    OperationContext.Current.OutgoingMessageProperties[HttpRequestMessageProperty.Name] = requestMessage;
                    ServiceAPI.response res = wsClient.wsCreateAccount(wsUser, wsPassword, "", msisdn);

                    if (res.errorCode == "0")
                    {
                        // signup success --> store session
                        SetLastSignUp();
                        CreateAuthToken(msisdn, null);
                        ReloadUserInfo(msisdn);
                    }

                    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)
        {

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

            String msisdn = validateMsisdn(phoneNumber);
            if (msisdn != "")
            {
                SetWsClient(ref wsClient, msisdn);
                using (new OperationContextScope(wsClient.InnerChannel))
                {
                    // Add a HTTP Header to an outgoing request
                    HttpRequestMessageProperty requestMessage = new HttpRequestMessageProperty();
                    requestMessage.Headers["lang"] = getCurrentLang();
                    OperationContext.Current.OutgoingMessageProperties[HttpRequestMessageProperty.Name] = requestMessage;
                    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
                });
            }
        }

    }
}