TEAMModelOS/TEAMModelOS.Service/Core/Implements/LoginInfoService.cs

using IdentityModel;
using Microsoft.Extensions.Options;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Claims;
using System.Threading.Tasks;
using TEAMModelOS.Model.Core.Dtos;
using TEAMModelOS.Model.Core.Models;
using TEAMModelOS.SDK.Context.Exception;
using TEAMModelOS.SDK.Extension.HttpClient.Implements;
using TEAMModelOS.SDK.Extension.JwtAuth.JwtHelper;
using TEAMModelOS.SDK.Extension.JwtAuth.Models;
using TEAMModelOS.SDK.Helper.Common.CollectionHelper;
using TEAMModelOS.SDK.Helper.Common.DateTimeHelper;
using TEAMModelOS.SDK.Module.AzureCosmosDB.Interfaces;
using TEAMModelOS.Service.Core.Interfaces;

namespace TEAMModelOS.Service.Core.Implements
{
    public class LoginInfoService : BaseService,  ILoginInfoService
    {
        private IAzureCosmosDBRepository repository;
        private readonly IOptions<JwtSetting> _options;
        private readonly HttpClientUserInfo _httpClientService;
        public LoginInfoService( IOptions<JwtSetting> options, HttpClientUserInfo httpClientService, IAzureCosmosDBRepository _repository)
        {
            _options = options;
            repository = _repository;
            _httpClientService = httpClientService;
        }

        public async Task<LoginResult> CheckLoginAsync(TicketInfo ticketInfo) {

           // string jtoken = HttpContextHelper.GetValueInHttp(_httpContextAccessor.HttpContext.Request, Constants.AUTHORIZATION);
            if (string.IsNullOrEmpty(ticketInfo.Token))
            {
                LoginResult result = new LoginResult();
                if (string.IsNullOrEmpty(ticketInfo.Ticket))
                {
                    result.CheckTicket = false;
                    return result;
                }
                //string code = BCryptHelper.Ecrypt(ticketInfo.Ticket + ticketInfo.TeamModelId);
                //bool f = BCryptHelper.Verify(ticketInfo.Ticket + ticketInfo.TeamModelId, ticketInfo.Sign);
                LoginInfo login = FindOneByKey<LoginInfo>("Ticket", ticketInfo.Ticket).Result;
                if (login != null && !string.IsNullOrEmpty(login.Token))
                {
                    result.CheckTicket = true;
                    JwtResponse token = await CreateJwtToken(login);
                    result.JwtToken = token;
                    login.Token = token.Access_token;
                    result.JwtToken.Scope = login.Scope;
                    await Update<LoginInfo>(login);
                    return result;
                }

                ///不验证TmdID
                #region
                result.CheckTicket = true;
                LoginInfo loginInfo = new LoginInfo
                {
                    PartitionKey = "15283771540",
                    Phone = "15283771540",
                    RowKey = Guid.NewGuid().ToString(),
                    TeamModelId = ticketInfo.TeamModelId,
                    Name = ticketInfo.Name,
                    Ticket = ticketInfo.Ticket,
                    CountryCode ="86"
                };
                List<TeamModelUser> users = await repository.FindByParams<TeamModelUser>(new Dictionary<string, object>() { { "TeamModelId", ticketInfo.TeamModelId } });
                TeamModelUser user = new TeamModelUser();
                if (users.IsEmpty())
                {
                    user = new TeamModelUser { id = Guid.NewGuid().ToString(), CountryCode = loginInfo.CountryCode, RegisterTime = DateTimeHelper.ConvertToTimeStamp13(DateTime.Now) };
                }
                else {
                    user = users[0];
                }
                user.Cellphone = "15283771540";
                user.NickName = ticketInfo.Name;
                if (string.IsNullOrEmpty(user.FullName))
                {
                    user.FullName = ticketInfo.Name;
                }
                user.TeamModelId = ticketInfo.TeamModelId;
                user.CountryCode = "86";
                JwtResponse jwtToken = await CreateJwtToken(loginInfo);
                loginInfo.Token = jwtToken.Access_token;
                loginInfo.Scope = jwtToken.Scope;
                result.JwtToken = jwtToken;
                await Save<LoginInfo>(loginInfo);
                await repository.Save<TeamModelUser>(user);
              //  JosnRPCResponse<TeamModelIdInfo> response = MessagePackHelper.JsonToObject<JosnRPCResponse<TeamModelIdInfo>>(jsonStr);
                return result;
                #endregion
                /*
                JosnRPCRequest<Dictionary<string, object>> request = new JosnRPCRequest<Dictionary<string, object>>
                {
                    method = "UserInfo"
                };
               
                    Dictionary<string, object> ticket = new Dictionary<string, object>
                {
                    { "ticket", ticketInfo.Ticket }
                };
                request.@params = ticket;
                string data = MessagePackHelper.ObjectToJson(request);
                string jsonStr = _httpClientService.HttpPost(BaseConfigModel.Configuration["HaBookAuth:AccountUrl"], data,  Constants.CONTENT_TYPE_JSON, Encoding.UTF8);
                if (!string.IsNullOrEmpty(jsonStr))
                {
                    JosnRPCResponse<TeamModelIdInfo> response = MessagePackHelper.JsonToObject<JosnRPCResponse<TeamModelIdInfo>>(jsonStr);
                    if (response.error == null && response != null)
                    {
                        result.CheckTicket = true;
                        LoginInfo loginInfo = new LoginInfo
                        {
                            PartitionKey = response.result.cellphone,
                            Phone = response.result.cellphone,
                            RowKey = Guid.NewGuid().ToString(),
                            TeamModelId = response.result.id,
                            Name = response.result.name,
                            Ticket = ticketInfo.Ticket,
                            CountryCode = response.result.countryCode
                        };
                        TeamModelUser user= await FindOneByKey<TeamModelUser>("TeamModelId", response.result.id);
                        if (user == null || string.IsNullOrEmpty(user.RowKey))
                        {
                            user = new TeamModelUser { RowKey = Guid.NewGuid().ToString(), PartitionKey = loginInfo.CountryCode ,RegisterTime=DateTimeHelper.ConvertToTimeStamp13(DateTime.Now) };
                        }
                        user.Cellphone = response.result.cellphone;
                        user.NickName = response.result.name;
                        if (string.IsNullOrEmpty(user.FullName)) {
                            user.FullName = response.result.name;
                        }
                        user.TeamModelId = response.result.id;
                        user.CountryCode = response.result.countryCode;
                        JwtResponse jwtToken = await CreateJwtToken(loginInfo);
                        loginInfo.Token = jwtToken.Access_token;
                        loginInfo.Scope = jwtToken.Scope;
                        result.JwtToken = jwtToken;
                        await Save<LoginInfo>(loginInfo);
                        await SaveOrUpdate<TeamModelUser>(user);
                        return result;
                    }
                    else
                    {
                        result.CheckTicket = false;
                        return result;
                    }
                }
                else
                {
                    result.CheckTicket = false;
                    return result;
                }
                */
            }
            else
            {
                ClaimModel claimModel = JwtHelper.SerializeJWT(ticketInfo.Token);

                var dateTime = DateTimeHelper.ConvertToTimeStamp10(DateTime.Now);
                var expExt=claimModel.Claim.TryGetValue("exp",out var exp);
                if (expExt==false || dateTime > long.Parse(exp.ToString()))
                {
                    throw new BizException(401, "Unauthorized");
                }
               
                Dictionary<string, object> msp = new Dictionary<string, object>
                {
                    { "Token", ticketInfo.Token }
                };
                LoginInfo loginInfo = FindOneByDict<LoginInfo>(msp).Result;
                if (loginInfo != null && !string.IsNullOrEmpty(loginInfo.Token))
                {
                    return new LoginResult { JwtToken = new JwtResponse { Access_token=loginInfo.Token ,Scope=loginInfo.Scope}, CheckTicket = true };
                }
                else
                {
                    throw new BizException(401, "Unauthorized");
                }
            }
        }
        public async Task<JwtResponse> CreateJwtToken(LoginInfo loginInfo)
        {
            Dictionary<string, object> dict = new Dictionary<string, object>
            {
                { "Phone", loginInfo.Phone },
                { "AreaCode", loginInfo.CountryCode },
                { "TeamModelId",  loginInfo.TeamModelId }
            };
            string role = "";
            List<RoleUser> roleUsers = await FindListByDict<RoleUser>(dict);
            if (roleUsers.IsNotEmpty())
            {
                foreach (RoleUser roleUser in roleUsers)
                {
                    role = role + roleUser.RoleCode + ",";
                }
                role = role.Substring(0, role.Length - 1);
            }
            else {
                role = "Teacher";
            }
           
            ClaimModel model = new ClaimModel
            {
                Scope = "WebApp"
            };
            model.Claims.Add(new Claim(JwtClaimTypes.Name, loginInfo.Name));
            model.Claims.Add(new Claim(JwtClaimTypes.Id, loginInfo.TeamModelId));
            ////保护隐私
            //model.Claims.Add(new Claim(JwtClaimTypes.PhoneNumber, loginInfo.Phone));
            model.Claims.AddRange(role.Split(',').Select(s => new Claim(JwtClaimTypes.Role, s)));
            model.Roles.Add(role);
            JwtResponse jwtResponse = JwtHelper.IssueJWT(model, _options.Value);
            return jwtResponse;
        }
        public Task<LoginInfo> SaveLoginInfoAsync(LoginInfo loginInfo)
        {
            return Save<LoginInfo>(loginInfo);
        }
    }
}