var row= await _fileRepository.UpdateDiy.Set(a => a.Path, path).ExecuteAffrowsAsync();

     public static FreeSqlBuilder CreateDatabaseIfNotExistsPgSql(this FreeSqlBuilder @this,
        string connectionString = "")
    {
        if (connectionString == "")
        {
            connectionString = GetConnectionString(@this);
        }

        NpgsqlConnectionStringBuilder builder = new NpgsqlConnectionStringBuilder(connectionString);
        
        string createDatabaseSql =
            $"DROP DATABASE IF EXISTS \"{builder.Database}\"; CREATE DATABASE \"{builder.Database}\" WITH OWNER = \"{builder.Username}\"";
       
        using NpgsqlConnection cnn = new NpgsqlConnection(
            $"Host={builder.Host};Port={builder.Port};Username={builder.Username};Password={builder.Password};Pooling=true");
        cnn.Open();
        using (NpgsqlCommand cmd = cnn.CreateCommand())
        {
            cmd.CommandText = createDatabaseSql;
            cmd.ExecuteNonQuery();
        }

        return @this;
    }

        bool valid = await _userIdentityService.VerifyUserPasswordAsync(currentUserId, passwordDto.OldPassword);
        if (!valid)
        {
            throw new LinCmsException("旧密码不正确");
        }

        await _userIdentityService.ChangePasswordAsync(currentUserId, passwordDto.NewPassword);
    }

     public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            return ConvertIntDateTime(double.Parse(reader.Value.ToString()));
        }

        public static DateTime ConvertIntDateTime(double milliseconds)
        {
            return new DateTime(1970, 1, 1).AddMilliseconds(milliseconds);
        }

        [HttpGet("signin-callback")]
        public async Task<IActionResult> Home(string provider, string redirectUrl = "")
        {
            if (string.IsNullOrWhiteSpace(provider))
            {
                return BadRequest();
            }

            if (!await HttpContext.IsProviderSupportedAsync(provider))
            {
                return BadRequest();
            }

            AuthenticateResult authenticateResult = await _contextAccessor.HttpContext.AuthenticateAsync(provider);
            if (!authenticateResult.Succeeded) return Redirect(redirectUrl);
            var openIdClaim = authenticateResult.Principal.FindFirst(ClaimTypes.NameIdentifier);
            if (openIdClaim == null || string.IsNullOrWhiteSpace(openIdClaim.Value))
                return Redirect(redirectUrl);
            long id = 0;
            switch (provider)
            {
                case LinUserIdentity.GitHub:
                    id = await _userCommunityService.SaveGitHubAsync(authenticateResult.Principal, openIdClaim.Value);
                    break;

                case LinUserIdentity.QQ:
                    id = await _userCommunityService.SaveQQAsync(authenticateResult.Principal, openIdClaim.Value);
                    break;

                case LinUserIdentity.Gitee:
                    string access_token = authenticateResult.Properties.GetTokenValue("access_token");
                    string refresh_token = authenticateResult.Properties.GetTokenValue("refresh_token");
                    string token_type = authenticateResult.Properties.GetTokenValue("token_type");
                    string expires_at = authenticateResult.Properties.GetTokenValue("expires_at");
                    id = await _userCommunityService.SaveGiteeAsync(authenticateResult.Principal, openIdClaim.Value);
                    break;
                case LinUserIdentity.WeiXin:

                    break;
                default:
                    _logger.LogError($"未知的privoder:{provider},redirectUrl:{redirectUrl}");
                    throw new LinCmsException($"未知的privoder:{provider}！");
            }
            List<Claim> authClaims = authenticateResult.Principal.Claims.ToList();

            LinUser user = await _userRepository.Select.IncludeMany(r => r.LinGroups)
                .WhereCascade(r => r.IsDeleted == false).Where(r => r.Id == id).FirstAsync();

            if (user == null)
            {
                throw new LinCmsException("第三方登录失败！");
            }
            List<Claim> claims = new List<Claim>()
            {
                new Claim (ClaimTypes.NameIdentifier, user.Id.ToString ()),
                new Claim (ClaimTypes.Email, user.Email?? ""),
                new Claim (ClaimTypes.GivenName, user.Nickname?? ""),
                new Claim (ClaimTypes.Name, user.Username?? ""),
            };

            user.LinGroups?.ForEach(r =>
           {
               claims.Add(new Claim(LinCmsClaimTypes.Groups, r.Id.ToString()));
           });

            //claims.AddRange(authClaims);
            string token = _jsonWebTokenService.Encode(claims);

            //TODO 生成刷新token
            //user.AddRefreshToken(token);
            //await _userRepository.UpdateAsync(user);

            return Redirect($"{redirectUrl}#login-result?token={token}");
        }

    /// <summary>
        /// 第三方账号绑定回调
        /// </summary>
        /// <param name="provider"></param>
        /// <param name="redirectUrl"></param>
        /// <param name="token"></param>
        /// <returns></returns>
        [HttpGet("signin-bind-callback")]
        public async Task<IActionResult> SignInBindCallBack(string provider, string redirectUrl = "", string token = "")
        {
            if (string.IsNullOrWhiteSpace(provider))
            {
                return BadRequest();
            }

            if (!await HttpContext.IsProviderSupportedAsync(provider))
            {
                return BadRequest();
            }

            if (token.IsNullOrEmpty() || !token.StartsWith("Bearer "))
            {
                return Redirect($"{redirectUrl}#bind-result?code={ErrorCode.Fail}&message={HttpUtility.UrlEncode("请先登录")}");
            }
            else
            {
                token = token.Remove(0, 7);
            }

            AuthenticateResult authenticateResult = await _contextAccessor.HttpContext.AuthenticateAsync(provider);
            if (!authenticateResult.Succeeded) return Redirect($"{redirectUrl}#bind-result?code=fail&message={authenticateResult.Failure.Message}");
            var openIdClaim = authenticateResult.Principal.FindFirst(ClaimTypes.NameIdentifier);
            if (openIdClaim == null || string.IsNullOrWhiteSpace(openIdClaim.Value))
                return Redirect($"{redirectUrl}#bind-result?code={ErrorCode.Fail}&message={HttpUtility.UrlEncode("未能获取openId")}");

            JwtPayload jwtPayload = (JwtPayload)_jsonWebTokenService.Decode(token);
            string nameIdentifier = jwtPayload.Claims.FirstOrDefault(r => r.Type == ClaimTypes.NameIdentifier)?.Value;
            if (nameIdentifier.IsNullOrWhiteSpace())
            {
                return Redirect($"{redirectUrl}#bind-result?code={ErrorCode.Fail}&message={HttpUtility.UrlEncode("请先登录")}");
            }
            long userId = long.Parse(nameIdentifier);
            UnifyResponseDto unifyResponseDto;
            switch (provider)
            {
                case LinUserIdentity.GitHub:
                    unifyResponseDto = await _userCommunityService.BindGitHubAsync(authenticateResult.Principal, openIdClaim.Value, userId);
                    break;
                case LinUserIdentity.QQ:
                    unifyResponseDto = await _userCommunityService.BindQQAsync(authenticateResult.Principal, openIdClaim.Value, userId);
                    break;
                case LinUserIdentity.Gitee:
                    unifyResponseDto = await _userCommunityService.BindGiteeAsync(authenticateResult.Principal, openIdClaim.Value, userId);
                    break;
                //case LinUserIdentity.WeiXin:

                //    break;
                default:
                    _logger.LogError($"未知的privoder:{provider},redirectUrl:{redirectUrl}");
                    unifyResponseDto = UnifyResponseDto.Error($"未知的privoder:{provider}！");
                    break;
            }

            return Redirect($"{redirectUrl}#bind-result?code={unifyResponseDto.Code.ToString()}&message={HttpUtility.UrlEncode(unifyResponseDto.Message.ToString())}");
        }

   public async Task<UnifyResponseDto> BindGitHubAsync(ClaimsPrincipal principal, string openId, long userId)
        {
            string name = principal.FindFirst(ClaimTypes.Name)?.Value;
            return await this.BindAsync(LinUserIdentity.GitHub, name, openId, userId);
        }

        public async Task<UnifyResponseDto> BindQQAsync(ClaimsPrincipal principal, string openId, long userId)
        {
            string nickname = principal.FindFirst(ClaimTypes.Name)?.Value;
            return await this.BindAsync(LinUserIdentity.QQ, nickname, openId, userId);
        }

        public async Task<UnifyResponseDto> BindGiteeAsync(ClaimsPrincipal principal, string openId, long userId)
        {
            string name = principal.FindFirst(ClaimTypes.Name)?.Value;
            return await this.BindAsync(LinUserIdentity.Gitee, name, openId, userId);
        }

        private async Task<UnifyResponseDto> BindAsync(string identityType, string name, string openId, long userId)
        {
            LinUserIdentity linUserIdentity = await _userIdentityRepository.Where(r => r.IdentityType == identityType && r.Credential == openId).FirstAsync();
            if (linUserIdentity == null)
            {
                var userIdentity = new LinUserIdentity(identityType, name, openId, DateTime.Now);
                userIdentity.CreateUserId = userId;
                await _userIdentityRepository.InsertAsync(userIdentity);
                return UnifyResponseDto.Success("绑定成功");
            }
            else
            {
                return UnifyResponseDto.Error("绑定失败,该用户已绑定其他账号");
            }
        }

  public async Task<long> SaveGitHubAsync(ClaimsPrincipal principal, string openId)
        {
           xxx
            return userId;
        }

        public async Task<long> SaveQQAsync(ClaimsPrincipal principal, string openId)
        {
           xxx
            return userId;
        }
        public async Task<long> SaveGiteeAsync(ClaimsPrincipal principal, string openId)
        {
            xxx
            return userId;
        }

name="Article.Editor",
value="markdown" 或 "富文本"，
provider_name为"User",
provider_key为用户Id

name="Qiniu.AK",
value="asfadsfadf23rft66S4XM2GIK7FGmj7czuYkcAyNGDAc" ，
provider_name为"Qiniu"或自己定义的字符串
provider_key为空

id  name        info
1	Admin	    系统管理员
2	CmsAdmin	内容管理员
3	User	    普通用户

id	                bigint
create_user_id  	bigint
create_time	        datetime
is_deleted	        bit
delete_user_id  	bigint
delete_time	        datetime
update_user_id	    bigint
update_time	        datetime

update lin_user set salt='9fd248c8-e9da-412f-bad9-aa5f7f1d7b80';
update lin_user_identity set credential='IWxIlqMAE3SU3JTogdDAJw==' where identity_type='Password';