CE/HiTeachCE/Controllers/LoginController.cs

using HiTeachCE.Extension;
using HiTeachCE.Helpers;
using HiTeachCE.Models;
using HiTeachCE.Services;
using IdentityModel;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Options;
using OpenXmlPowerTools;
using Org.BouncyCastle.Ocsp;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Security.Claims;
using System.Text.Json;
using System.Threading.Tasks;
using TEAMModelOS.SDK.Context.Configuration;
using TEAMModelOS.SDK.Context.Exception;
using TEAMModelOS.SDK.Extension.DataResult.JsonRpcRequest;
using TEAMModelOS.SDK.Extension.DataResult.JsonRpcResponse;
using TEAMModelOS.SDK.Extension.JwtAuth.Models;
using TEAMModelOS.SDK.Helper.Common.CollectionHelper;
using TEAMModelOS.SDK.Helper.Common.JsonHelper;
using TEAMModelOS.SDK.Helper.Security.ShaHash;

namespace HiTeachCE.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class LoginController : BaseController
    {

        public static int smsTTL = 4 * 60;
        public static int ticketTTL = 10 * 60;
        public static int freeTTL = 7 * 24 * 60 * 60;
        public static int deviceTTL=1 * 24 * 60 * 60;
        public static string freeOrg = "7f847a9f05224184a5d01ee69a6b00d6";
        public static string model_teach = "teach";
        public static string model_prepare = "prepare";
        private readonly LecturerService lecturerService;
        private readonly OrganizationService organizationService;
        private readonly MemberService memberService;
        private readonly ActivationCodeService activationCodeService;
        public readonly IOptions<Extension.JwtSetting> options;
        public LoginController(LecturerService lecturer, OrganizationService organization, MemberService member, ActivationCodeService activationCode, IOptions<Extension.JwtSetting> _options)
        {
            lecturerService = lecturer;
            organizationService = organization;
            memberService = member;
            activationCodeService = activationCode;
            options = _options;
        }
        /// <summary>
        /// 注册装置
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("regist")]
        [Authorize]
        public BaseJosnRPCResponse Regist(JosnRPCRequest<Dictionary<string, string>> request)
        {
            JsonRPCResponseBuilder builder = JsonRPCResponseBuilder.custom();
            List<string> ClientId = //new List<string>() { "fb564dde14df423cafac2085936e3b96" };
           GetLoginUser(JwtClaimTypes.ClientId);
            /**
             "params": {
                    "deviceId": "f67fb5dd-ee1b-d3b7-9b95-61022d7e8acd",
                    "clientId": "931dee8c-74be-4c9b-a602-c74583b0e985",
                }
             */
            if (request.@params.TryGetValue("deviceId", out string deviceId) && ClientId.IsNotEmpty())
            {
                if (RedisHelper.HExists("device:" + ClientId[0], deviceId))
                {
                }
                else
                {
                    RedisHelper.HSet("device:" + ClientId[0], deviceId, null);
                    RedisHelper.Expire("device:" + ClientId[0], deviceTTL);
                }
                return  builder.Data(new Dictionary<string, object> { { "deviceId", deviceId } }).build();
            }
            else {
                throw new BizException("参数错误", 2);
            }
             
        }

        /// <summary>
        /// 创建教室
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("createGroup")]
        [Authorize]
        public BaseJosnRPCResponse CreateGroup(JosnRPCRequest<Dictionary<string, string>> request)
        {
            /**
             "params": {
		            "deviceId": "f67fb5dd-ee1b-d3b7-9b95-61022d7e8acd",
		            "doBoundGroupNum": false,
		            "extraInfo": {}
	            }
             */

            JsonRPCResponseBuilder builder = JsonRPCResponseBuilder.custom();
            List<string> ClientId =// new List<string>() { "fb564dde14df423cafac2085936e3b96" };
                 GetLoginUser(JwtClaimTypes.ClientId);
            string groupNum ;
            if (request.@params.TryGetValue("deviceId", out string deviceId) && ClientId.IsNotEmpty())
            {
                if (RedisHelper.HExists("device:" + ClientId[0], deviceId))
                {
                    groupNum= RedisHelper.HGet<string>("device:" + ClientId[0], deviceId);
                    if (string.IsNullOrEmpty(groupNum)) {
                        do
                        {
                            groupNum = RandGroupNum();
                        } while (RedisHelper.Exists("group:" + groupNum));
                        RedisHelper.HSet("group:" + groupNum, deviceId, null);
                        RedisHelper.Expire("group:" + groupNum, deviceTTL);
                        RedisHelper.HSet("device:" + ClientId[0], deviceId, groupNum);
                    }
                }
                else { throw new BizException("装置未注册", 2); }
            }
            else {
                throw new BizException("参数错误", 2);
            }
            return builder.Data(groupNum).build();
        }
        public string RandGroupNum() {
            Random random = new Random();
            String result = "";
            for (int i = 0; i < 6; i++)
            {
                result += random.Next(0,10);
            }
            return result;
        }
        /// <summary>
        /// 加入教室
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("joinGroup")]
        [Authorize]
        public BaseJosnRPCResponse JoinGroup(JosnRPCRequest<Dictionary<string, string>> request)
        {
            List<string> ClientId = //new List<string>() { "fb564dde14df423cafac2085936e3b96" };
             GetLoginUser(JwtClaimTypes.ClientId);
            JsonRPCResponseBuilder builder = JsonRPCResponseBuilder.custom();
            Dictionary<string, object> dict;
            /**
             "params": {
		            "deviceId": "f67fb5dd-ee1b-d3b7-9b95-61022d7e8acd",
		            "groupNum": "818288"
	            }
             */
            if (request.@params.TryGetValue("deviceId", out string deviceId) && 
                request.@params.TryGetValue("groupNum", out string groupNum)&&
                !string.IsNullOrEmpty(deviceId) && !string.IsNullOrEmpty(groupNum)
                )
            {
                if (RedisHelper.Exists("group:" + groupNum))
                {
                    dict =  MqttInfo(ClientId, deviceId, groupNum);
                }
                else {
                    throw new BizException("教室不存在", 2);
                }
            }
            else
            {
                throw new BizException("参数错误", 2);
            }
          
            return builder.Data(dict).build();
        }

        private static Dictionary<string, object> MqttInfo(List<string> ClientId,  string deviceId, string groupNum)
        {
            Dictionary<string, object> dict = new Dictionary<string, object>();
            string password = "cdhabook.teammodel.cn/" + groupNum +"/"+ deviceId +"/"+ ClientId[0];
            //发给前端使用的
            string h1 = BCrypt.Net.BCrypt.HashPassword(password);
            //后端存储使用的
            string h2 = BCrypt.Net.BCrypt.HashPassword(h1);
            bool validPassword = BCrypt.Net.BCrypt.Verify(h1, h2);
            string uname = password;
            Dictionary<string, string> connectInfo = new Dictionary<string, string>() {
                        { "brokerHostName", "cdhabook.teammodel.cn" },
                        { "brokerHostNameWSS", "wss://cdhabook.teammodel.cn/mqtt" },
                        { "clientID", deviceId },
                        //使用BCrypt加密
                        { "password",h1 },
                        { "username",uname }
                    };
            dynamic groupMember = new
            {
                deviceId,
                username = uname,
                password = h2
            };
            RedisHelper.HSet("group:" + groupNum, deviceId, groupMember);
            Dictionary<string, string> subscribeTopic = BaseConfigModel.Configuration.GetSection("SubscribeTopic").Get<Dictionary<string, string>>();
            subscribeTopic["receiveMsg"] = subscribeTopic["receiveMsg"].Replace("{deviceId}", deviceId);
            Dictionary<string, string> publishTopic = BaseConfigModel.Configuration.GetSection("PublishTopic").Get<Dictionary<string, string>>();
            publishTopic["sendMsg"] = publishTopic["sendMsg"].Replace("{deviceId}", deviceId).Replace("{groupNum}", groupNum);
            dict.Add("mqtt", new Dictionary<string, object>() { { "connectInfo", connectInfo },{ "publishTopic", publishTopic },{ "subscribeTopic", subscribeTopic } });
            return dict;
        }

        /// <summary>
        /// 认证
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("auth")]
        public BaseJosnRPCResponse auth(JosnRPCRequest<Dictionary<string, string>> request)
        {
            JsonRPCResponseBuilder builder = JsonRPCResponseBuilder.custom();
            if (request.@params.TryGetValue("ticket", out string ticket) &&
                //上课模式  备课模式
                //request.@params.TryGetValue("model", out string model)&&
              //  (model.Equals(model_teach )||model.Equals(model_prepare)) &&
                request.@params.TryGetValue("orgCode", out string orgCode)
                )
            {
                if (RedisHelper.Exists("ticket:" + ticket))
                {
                    string[] vals = RedisHelper.HVals<string>("ticket:" + ticket);
                    if (vals != null && vals.Length > 0)
                    {
                        string cellphone = vals[0];
                        Expression<Func<Lecturer, bool>> linq = null;
                        linq = m => m.cellphone == cellphone;
                        List<Lecturer> lecturers = lecturerService.GetList(linq);
                        if (lecturers.IsNotEmpty())
                        {
                            Expression<Func<Member, bool>> mlinq = null;
                            mlinq = m => m.unionid == lecturers[0].unionid && m.orgCode == orgCode;
                            List<Member> members = memberService.GetList(mlinq);
                            if (members.IsNotEmpty())
                            {
                                if (members[0].expires == -1 || new DateTimeOffset(DateTime.UtcNow).ToUnixTimeSeconds() < members[0].expires)
                                {
                                    //永久用户及授权期内的用户
                                    //调用ActivationCode
                                    return builder.Data(ActivationValid(orgCode, lecturers[0])).build();
                                }
                                else
                                {
                                    //授权过期
                                    throw new BizException("用户授权过期", 2);
                                }
                            }
                            else
                            {
                                if (orgCode.Equals(freeOrg))
                                {
                                    long time = new DateTimeOffset(DateTime.UtcNow).ToUnixTimeSeconds();
                                    ///处理该机构是否激活人数达到上线
                                    Expression<Func<Member, bool>> limitlinq = null;
                                    limitlinq = m => m.orgCode == orgCode && (m.expires > time || m.expires == -1) && m.status == 1;
                                    List<Member> countMembers = memberService.GetList(limitlinq);
                                    Expression<Func<ActivationCode, bool>> alinq = null;
                                    alinq = m => m.orgCode == orgCode && m.status == 1;
                                    List<ActivationCode> activationCodes = activationCodeService.GetList(alinq);
                                    if (activationCodes.IsNotEmpty())
                                    {
                                        //判断组织机构人员是否已经达到最大激活数量
                                        if (countMembers.IsNotEmpty() && countMembers.Count >= activationCodes[0].maximum)
                                        {
                                            throw new BizException("产品授权人数超过上限！", 2);
                                        }
                                        else
                                        {
                                            Member member = new Member
                                            {
                                                id = Guid.NewGuid().ToString(),
                                                orgCode = orgCode,
                                                role = "lecturer",
                                                status = 1,
                                                expires = time + freeTTL,
                                                unionid = lecturers[0].unionid
                                            };
                                            bool flag = memberService.Insert(member);
                                            if (flag)
                                            {
                                                //调用ActivationCode
                                                return builder.Data(ActivationValid(orgCode, lecturers[0])).build();
                                            }
                                            else
                                            {
                                                throw new BizException("无法加入:HiTeachCE(测试)！", 2);
                                            }
                                        }
                                    }
                                    else
                                    {
                                        throw new BizException("产品未授权该组织或个人！", 2);
                                    }
                                }
                                else
                                {
                                    throw new BizException("授权失败！", 2);
                                }
                            }
                        }
                        else
                        {
                            throw new BizException("登录用户不存在！", 2);
                        }
                    }
                    else
                    {
                        throw new BizException("凭据过期！", 2);
                    }
                }
                else
                {
                    throw new BizException("凭据过期！", 2);
                }
            }
            else
            {
                throw new BizException("参数错误！", 2);
            }
        }

        public JwtResponse ActivationValid(string orgCode, Lecturer lecturer)
        {
            //验证组织机构的激活码状态，时间，最大人数
            Expression<Func<ActivationCode, bool>> linq = null;
            linq = m => m.orgCode == orgCode && m.status == 1;
            List<ActivationCode> activationCodes = activationCodeService.GetList(linq);
            if (activationCodes.IsNotEmpty())
            {
                long time = new DateTimeOffset(DateTime.UtcNow).ToUnixTimeSeconds();
                if (activationCodes[0].expires > time || activationCodes[0].expires == -1)
                {
                    int max = activationCodes[0].maximum;
                    Expression<Func<Member, bool>> mlinq = null;
                    mlinq = l => l.orgCode == orgCode;
                    List<Member> members = memberService.GetList(mlinq);
                    if (members.Count >= max)
                    {
                        throw new BizException("产品授权人数超过上限！", 2);
                    }
                    else
                    {
                        // 未授权用户授权 生成JWT
                        if (members.Where(x => x.status == 1 && (x.expires > time || x.expires == -1)).Select(x => x.unionid).ToList().Contains(lecturer.unionid))
                        {
                            string role = members.Where(x => x.unionid == lecturer.unionid && x.status == 1 && (x.expires > time || x.expires == -1)).First().role;
                            ClaimModel claimModel = new ClaimModel
                            {
                                Scope = "WebApp"
                            };
                            claimModel.Claims.Add(new Claim(JwtClaimTypes.Name, lecturer.username));
                            claimModel.Claims.Add(new Claim(JwtClaimTypes.Id, lecturer.unionid));
                            claimModel.Claims.Add(new Claim(JwtClaimTypes.PhoneNumber, lecturer.cellphone));
                            claimModel.Claims.Add(new Claim(JwtClaimTypes.Role, role));
                            claimModel.Claims.Add(new Claim(JwtClaimTypes.ClientId, activationCodes[0].clientId));
                            claimModel.Claims.Add(new Claim("org", orgCode));
                            JwtResponse jwtResponse = JwtHelper.IssueJWT(claimModel);
                            return jwtResponse;
                        }
                        else
                        {
                            throw new BizException("组织机构未对该用户授权或已经过期！", 2);
                        }
                    }
                }
                else
                {
                    throw new BizException("产品授权已经过期！", 2);
                }
            }
            else
            {
                throw new BizException("产品未授权该组织或个人！", 2);
            }
        }

        //register user
        [HttpPost("register")]
        public BaseJosnRPCResponse Register(JosnRPCRequest<RegisterDto> request) {
            JsonRPCResponseBuilder builder = JsonRPCResponseBuilder.custom();
            if (RedisHelper.Exists("ticket:" + request.@params.ticket))
            {
                if (request.@params.user != null)
                {
                    string[] phone= RedisHelper.HVals("ticket:" + request.@params.ticket);
                    if (phone.IsNotEmpty())
                    {
                        if (!request.@params.user.cellphone.Equals(phone[0])) {
                            throw new BizException("手机号与凭证不匹配！", 2);
                        }
                    }
                    else {
                        throw new BizException("凭证无效！", 2);
                    }
                    Expression<Func<Lecturer, bool>> linq = null;
                    linq = m => m.cellphone == request.@params.user.cellphone || m.account == request.@params.user.account;
                    List<Lecturer> lecturers = lecturerService.GetList(linq);
                    if (lecturers.IsNotEmpty())
                    {
                        throw new BizException("手机号或账号已经存在！", 2);
                    }
                    else
                    {
                        request.@params.user.id = Guid.NewGuid().ToString();
                        request.@params.user.unionid = Guid.NewGuid().ToString("N");
                        request.@params.user.unionid = "86";
                        if (request.@params.user.password == null)
                        {
                            request.@params.user.password = "";
                        }
                        bool ib = lecturerService.Insert(request.@params.user);
                        if (ib)
                        {
                            return builder.Data(ib).build();
                        }
                        else
                        {
                            throw new BizException("注册失败！", 2);
                        }
                    }
                }
                else
                {
                    throw new BizException("参数错误！", 2);
                }
            }
            else {
                throw new BizException("短信验证过期！", 2);
            }
            

        }

        public class RegisterDto { 
            public Lecturer user { get; set; }
            public string ticket { get; set; }
        }
        /// <summary>
        /// 登录
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("phoneLogin")]
        public async Task<BaseJosnRPCResponse> PhoneLogin(JosnRPCRequest<Dictionary<string, string>> request)
        {
            JsonRPCResponseBuilder builder = JsonRPCResponseBuilder.custom();
            if (request.@params.TryGetValue("cellphone", out string cellphone) &&
                request.@params.TryGetValue("smsCode", out string smsCode)
                )
            {
                string ticket = ShaHashHelper.GetSHA1(cellphone + smsCode);
                if (RedisHelper.Exists("ticket:" + ticket))
                {
                    Dictionary<string, object> dict = userValid(cellphone);
                    dict.Add("ticket", ticket);
                    return builder.Data(dict).build();
                }
                if (RedisHelper.Exists(cellphone))
                {
                    string[] vals = RedisHelper.HVals<string>(cellphone);
                    if (vals != null && vals.Length > 0)
                    {
                        string resdata = await HttpClientHelper.Post(
                        BaseConfigModel.Configuration["JPush:Valid"].Replace("{msg_id}", vals[0]),
                        BaseConfigModel.Configuration["JPush:AppKey"],
                        BaseConfigModel.Configuration["JPush:Secret"], new Dictionary<string, object> { { "code", smsCode } });
                        JsonElement element = resdata.FromApiJson<JsonElement>();
                        if (element.TryGetProperty("is_valid", out JsonElement json))
                        {
                            if (json.GetBoolean())
                            {
                                ///验证通过 验证信息存放在reids
                                RedisHelper.HSet("ticket:" + ticket, cellphone, cellphone);
                                RedisHelper.Expire("ticket:" + ticket, ticketTTL);
                                Dictionary<string, object> dict = userValid(cellphone);
                                dict.Add("ticket", ticket);
                                return builder.Data(dict).build();
                            }
                            else
                            {
                                throw new BizException("短信验证码过期！", 2);
                            }
                        }
                        else
                        {
                            throw new BizException("短信验证码过期！", 2);
                        }
                    }
                    else
                    {
                        throw new BizException("短信验证码过期！", 2);
                    }
                }
                else
                {
                    throw new BizException("短信验证码过期！", 2);
                }
            }
            else
            {
                throw new BizException("手机号、短信验证码未填写！", 2);
            }

            //如果验证通过则将验证信息缓存至redis 以防再次远程验证不通过

            //string uid = "";
            //List<Organization> organizations = GetOrgByUid(uid);
            //return builder.Data(organizations).build();
        }
        //  [HttpPost("GetOrgByUid")]
        public List<Organization> GetOrgByUid(string uid)
        {
            Expression<Func<Member, bool>> mlinq = null;
            mlinq = m => m.unionid == uid && (m.expires > 0 || m.expires == -1) && m.status == 1;
            List<Member> members = memberService.GetList(mlinq);
            if (members.IsNotEmpty())
            {
                Expression<Func<Organization, bool>> olinq = null;
                olinq = o => members.Select(x => x.orgCode).ToList().Contains(o.code) && o.status == 1;
                List<Organization> organizations = organizationService.GetList(olinq);
                ///返回前端后倒计时10秒自动选择组织机构，以防再次验证的时候 reids过期
                return organizations;
            }
            else { return null; }
        }

        private Dictionary<string, object> userValid(string cellphone)
        {
            Expression<Func<Lecturer, bool>> linq = null;
            linq = m => m.cellphone == cellphone;
            List<Lecturer> lecturers = lecturerService.GetList(linq);
            if (lecturers.IsNotEmpty())
            {
                //用户存在则返回组织机构信息
                List<Organization> organizations = GetOrgByUid(lecturers[0].unionid);
                if (organizations.IsNotEmpty())
                {
                    return new Dictionary<string, object> {
                                        { "status",2},
                                        { "org",organizations},
                                    };
                }
                else
                {
                    //测试组织机构
                    Expression<Func<Organization, bool>> olinq = null;
                    olinq = o =>o.code==freeOrg && o.status == 1;
                    return new Dictionary<string, object> { { "status", 3 }, { "org", organizationService.GetList(olinq) } };
                }
            }
            else
            {
                //不存在用户则新增一个
                Random random = new Random();
                string seed = new string(Constant.az09);
                string pfx = "";
                for (int i = 0; i < 4; i++)
                {
                    string c = seed.ToCharArray()[random.Next(0, seed.Length)] + "";
                    seed.Replace(c, "");
                    pfx = pfx + c;
                }
                return new Dictionary<string, object> {
                                        { "status",1},
                                        { "user",new Lecturer
                                            {
                                                id= Guid.NewGuid().ToString(),
                                                unionid= Guid.NewGuid().ToString("N"),
                                                username=cellphone+"手机用户",
                                                password="",
                                                account="hitmd-"+cellphone.Substring(cellphone.Length-4,4)+"#"+pfx,
                                                areaCode="86",
                                                registerTime=new DateTimeOffset(DateTime.UtcNow).ToUnixTimeSeconds(),
                                                status=1,
                                                setaccount=0,
                                                cellphone=cellphone
                                            }
                                        }
                                    };
            }
        }



        /// <summary>
        /// 初始化登录
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("init")]
        public BaseJosnRPCResponse Init(JosnRPCRequest<Dictionary<string, object>> request)
        {
            JsonRPCResponseBuilder builder = JsonRPCResponseBuilder.custom();
            return builder.Data(Guid.NewGuid().ToString("N")).build();
        }


        /// <summary>
        /// 发送短信
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost("sendSMS")]
        public async Task<BaseJosnRPCResponse> sendSMS(JosnRPCRequest<string> request)
        {
            JsonRPCResponseBuilder builder = JsonRPCResponseBuilder.custom();
            string key = request.@params;
            if (!string.IsNullOrEmpty(key))
            {
                if (RedisHelper.Exists(key))
                {
                    string[] vals = RedisHelper.HVals<string>(key);
                    if (vals != null && vals.Length > 0)
                    {
                        Dictionary<string, object> data = new Dictionary<string, object>() { { "msgid", vals[0] }, { "repeat", true } };
                        return builder.Data(data).build();
                    }
                    else
                    {
                        return builder.Data(await sendMsg(key)).build();
                    }
                }
                else
                {
                    return builder.Data(await sendMsg(key)).build();
                }
            }
            else
            {
                throw new BizException("请输入手机号！", 2);
            }
        }

        private static async Task<Dictionary<string, object>> sendMsg(string key)
        {
            Dictionary<string, object> data = new Dictionary<string, object>() { { "mobile", key }, { "temp_id", 1 }, { "sign_id", "" } };
            string resdata = await HttpClientHelper.Post(
                BaseConfigModel.Configuration["JPush:Push"],
                BaseConfigModel.Configuration["JPush:AppKey"],
                BaseConfigModel.Configuration["JPush:Secret"], data);
            JsonElement element = resdata.FromApiJson<JsonElement>();
            if (element.TryGetProperty("msg_id", out JsonElement msgid))
            {
                string msgidstr = msgid.GetString();
                RedisHelper.Del(new string[] { key });
                RedisHelper.HSet(key, key, msgidstr);
                RedisHelper.Expire(key, smsTTL);
                return new Dictionary<string, object>() { { "msgid", msgidstr }, { "repeat", false } };
            }
            else
            {
                throw new BizException("短信发送失败！", 2);
            }
        }
    }
}