第三方OAuth授权登录，QQ、微信（WeChat）、微博、GitHub、码云（Gitee）、淘宝（天猫）、微软（Microsoft ）、钉钉、谷歌（Google）、支付宝（AliPay）、*

netnr.login

第三方oauth授权登录

支持第三方登录

三方	参考文档
	参考文档
	参考文档
	参考文档

---

安装 (nuget)

install-package netnr.login

修改配置信息（密钥、回调等）

提醒：一般所有第三方登录都有一个 state 参数，用于防止csrf攻击（防伪），可以利用该参数添加 登录、注册 的标注前缀

框架

• .netstandard 2.1
• .netframework 4.0

使用

/*
 * 这是测试代码，只为调通每一个接口，拿到 唯一标识
 * 实际应用中还要处理昵称、邮箱、头像等，可参考个站开源项目：https://github.com/netnr/blog
 */

using system;

namespace netnr.login.sample
{
    class program
    {
        static void main(string[] args)
        {
            var lc = new loginclient(loginbase.logintype.*);

            //拷贝授权链接在浏览器打开，授权后拿到code，并手动赋值，手动赋值需解码
            var url = lc.auth();

            var ar = new loginbase.authorizeresult();
            ar.code = "";
            //此处打断点，赋值上面拿到的code再继续
            ar.code = ar.code.todecode();

            lc.authcallback(ar);
        }

        public class loginclient
        {
            private loginbase.logintype? logintype;

            public loginclient(loginbase.logintype _logintype)
            {
                logintype = _logintype;

                // 配置
                qqconfig.appid = "xxx";
                qqconfig.appkey = "xxx";
                //回调地址，与申请填写的地址保持一致
                qqconfig.redirect_uri = "https://rf2.netnr.com/account/authcallback/qq";

                wechatconfig.appid = "";
                wechatconfig.appsecret = "";
                wechatconfig.redirect_uri = "";

                weiboconfig.appkey = "";
                weiboconfig.appsecret = "";
                weiboconfig.redirect_uri = "";

                githubconfig.clientid = "";
                githubconfig.clientsecret = "";
                githubconfig.redirect_uri = "";
                //申请的应用名称，非常重要
                githubconfig.applicationname = "netnrf";

                taobaoconfig.appkey = "";
                taobaoconfig.appsecret = "";
                taobaoconfig.redirect_uri = "";

                microsoftconfig.clientid = "";
                microsoftconfig.clientsecret = "";
                microsoftconfig.redirect_uri = "";

                dingtalkconfig.appid = "";
                dingtalkconfig.appsecret = "";
                dingtalkconfig.redirect_uri = "";

                giteeconfig.clientid = "";
                giteeconfig.clientsecret = "";
                giteeconfig.redirect_uri = "";

                googleconfig.clientid = "";
                googleconfig.clientsecret = "";
                googleconfig.redirect_uri = "";

                alipayconfig.appid = "";
                alipayconfig.appprivatekey = "";
                alipayconfig.redirect_uri = "";

                *config.clientid = "";
                *config.clientsecret = "";
                *config.key = "";
                *config.redirect_uri = "";
            }

            /// <summary>
            /// 生成请求链接
            /// </summary>
            /// <param name="authtype">在防伪参数追加信息（可用于登录、注册、绑定、解绑区分）</param>
            /// <returns></returns>
            public string auth(string authtype = "")
            {
                var url = string.empty;

                switch (logintype)
                {
                    case loginbase.logintype.qq:
                        {
                            var reqe = new qq_authorization_requestentity();
                            if (!string.isnullorwhitespace(authtype))
                            {
                                reqe.state = authtype + reqe.state;
                            }
                            url = qq.authorizationhref(reqe);
                        }
                        break;
                    case loginbase.logintype.weibo:
                        {
                            var reqe = new weibo_authorize_requestentity();
                            if (!string.isnullorwhitespace(authtype))
                            {
                                reqe.state = authtype + reqe.state;
                            }
                            url = weibo.authorizehref(reqe);
                        }
                        break;
                    case loginbase.logintype.github:
                        {
                            var reqe = new github_authorize_requestentity();
                            if (!string.isnullorwhitespace(authtype))
                            {
                                reqe.state = authtype + reqe.state;
                            }
                            url = github.authorizehref(reqe);
                        }
                        break;
                    case loginbase.logintype.taobao:
                        {
                            var reqe = new taobao_authorize_requestentity();
                            if (!string.isnullorwhitespace(authtype))
                            {
                                reqe.state = authtype + reqe.state;
                            }
                            url = taobao.authorizehref(reqe);
                        }
                        break;
                    case loginbase.logintype.microsoft:
                        {
                            var reqe = new microsoft_authorize_requestentity();
                            if (!string.isnullorwhitespace(authtype))
                            {
                                reqe.state = authtype + reqe.state;
                            }
                            url = microsoft.authorizehref(reqe);
                        }
                        break;
                    case loginbase.logintype.wechat:
                        {
                            var reqe = new wechat_authorization_requestentity();
                            if (!string.isnullorwhitespace(authtype))
                            {
                                reqe.state = authtype + reqe.state;
                            }
                            url = wechat.authorizationhref(reqe);
                        }
                        break;
                    case loginbase.logintype.dingtalk:
                        {
                            var reqe = new dingtalk_authorize_requestentity();
                            if (!string.isnullorwhitespace(authtype))
                            {
                                reqe.state = authtype + reqe.state;
                            }
                            //扫描模式
                            url = dingtalk.authorizehref_scancode(reqe);

                            //密码模式
                            //url = dingtalk.authorizehref_password(reqe);
                        }
                        break;
                    case loginbase.logintype.gitee:
                        {
                            var reqe = new gitee_authorize_requestentity();
                            if (!string.isnullorwhitespace(authtype))
                            {
                                reqe.state = authtype + reqe.state;
                            }
                            url = gitee.authorizehref(reqe);
                        }
                        break;
                    case loginbase.logintype.google:
                        {
                            var reqe = new google_authorize_requestentity();
                            if (!string.isnullorwhitespace(authtype))
                            {
                                reqe.state = authtype + reqe.state;
                            }
                            url = google.authorizehref(reqe);
                        }
                        break;
                    case loginbase.logintype.alipay:
                        {
                            var reqe = new alipay_authorize_requestentity();
                            if (!string.isnullorwhitespace(authtype))
                            {
                                reqe.state = authtype + reqe.state;
                            }
                            url = alipay.authorizehref(reqe);
                        }
                        break;
                    case loginbase.logintype.*:
                        {
                            var reqe = new *_authorize_requestentity();
                            if (!string.isnullorwhitespace(authtype))
                            {
                                reqe.state = authtype + reqe.state;
                            }
                            url = *.authorizehref(reqe);
                        }
                        break;
                }

                return url;
            }

            /// <summary>
            /// 回调方法
            /// </summary>
            /// <param name="authorizeresult">接收授权码、防伪参数</param>
            public void authcallback(loginbase.authorizeresult authorizeresult)
            {
                if (string.isnullorwhitespace(authorizeresult.code))
                {
                    //打开链接没登录授权
                }
                else
                {
                    //唯一标示
                    string openid = string.empty;

                    switch (logintype)
                    {
                        case loginbase.logintype.qq:
                            {
                                //获取 access_token
                                var tokenentity = qq.accesstoken(new qq_accesstoken_requestentity()
                                {
                                    code = authorizeresult.code
                                });

                                //获取 opendid
                                var openidentity = qq.openid(new qq_openid_requestentity()
                                {
                                    access_token = tokenentity.access_token
                                });

                                //获取 userinfo
                                _ = qq.openid_get_user_info(new qq_openapi_requestentity()
                                {
                                    access_token = tokenentity.access_token,
                                    openid = openidentity.openid
                                });

                                //身份唯一标识
                                openid = openidentity.openid;
                            }
                            break;
                        case loginbase.logintype.weibo:
                            {
                                //获取 access_token
                                var tokenentity = weibo.accesstoken(new weibo_accesstoken_requestentity()
                                {
                                    code = authorizeresult.code
                                });

                                //获取 access_token 的授权信息
                                var tokeninfoentity = weibo.gettokeninfo(new weibo_gettokeninfo_requestentity()
                                {
                                    access_token = tokenentity.access_token
                                });

                                //获取 users/show
                                _ = weibo.usershow(new weibo_usershow_requestentity()
                                {
                                    access_token = tokenentity.access_token,
                                    uid = convert.toint64(tokeninfoentity.uid)
                                });

                                openid = tokenentity.access_token;
                            }
                            break;
                        case loginbase.logintype.wechat:
                            {
                                //获取 access_token
                                var tokenentity = wechat.accesstoken(new wechat_accesstoken_requestentity()
                                {
                                    code = authorizeresult.code
                                });

                                //获取 user
                                _ = wechat.get_user_info(new wechat_openapi_requestentity()
                                {
                                    access_token = tokenentity.access_token,
                                    openid = tokenentity.openid
                                });

                                //身份唯一标识
                                openid = tokenentity.openid;
                            }
                            break;
                        case loginbase.logintype.github:
                            {
                                //获取 access_token
                                var tokenentity = github.accesstoken(new github_accesstoken_requestentity()
                                {
                                    code = authorizeresult.code
                                });

                                //获取 user
                                var userentity = github.user(new github_user_requestentity()
                                {
                                    access_token = tokenentity.access_token
                                });

                                openid = userentity.id.tostring();
                            }
                            break;
                        case loginbase.logintype.taobao:
                            {
                                //获取 access_token
                                var tokenentity = taobao.accesstoken(new taobao_accesstoken_requestentity()
                                {
                                    code = authorizeresult.code
                                });

                                openid = tokenentity.open_uid;
                            }
                            break;
                        case loginbase.logintype.microsoft:
                            {
                                //获取 access_token
                                var tokenentity = microsoft.accesstoken(new microsoft_accesstoken_requestentity()
                                {
                                    code = authorizeresult.code
                                });

                                //获取 user
                                var userentity = microsoft.user(new microsoft_user_requestentity()
                                {
                                    access_token = tokenentity.access_token
                                });

                                openid = userentity.id.tostring();
                            }
                            break;
                        case loginbase.logintype.dingtalk:
                            {
                                //获取 user
                                var userentity = dingtalk.user(new dingtalk_user_requestentity(), authorizeresult.code);

                                openid = userentity?.openid;
                            }
                            break;
                        case loginbase.logintype.gitee:
                            {
                                //获取 access_token
                                var tokenentity = gitee.accesstoken(new gitee_accesstoken_requestentity()
                                {
                                    code = authorizeresult.code
                                });

                                //获取 user
                                var userentity = gitee.user(new gitee_user_requestentity()
                                {
                                    access_token = tokenentity.access_token
                                });

                                openid = userentity.id.tostring();
                            }
                            break;
                        case loginbase.logintype.google:
                            {
                                //获取 access_token
                                var tokenentity = google.accesstoken(new google_accesstoken_requestentity()
                                {
                                    code = authorizeresult.code
                                });

                                //获取 user
                                var userentity = google.user(new google_user_requestentity()
                                {
                                    access_token = tokenentity.access_token
                                });

                                openid = userentity.sub;
                            }
                            break;
                        case loginbase.logintype.alipay:
                            {
                                //获取 access_token
                                var tokenentity = alipay.accesstoken(new alipay_accesstoken_requestentity()
                                {
                                    code = authorizeresult.auth_code
                                });

                                //实际上这一步已经获取到 openid，登录验证可以了，获取个人信息还需调用下面的接口
                                //tokenentity.user_id

                                //获取 user
                                var userentity = alipay.user(new alipay_user_requestentity()
                                {
                                    auth_token = tokenentity.access_token
                                });

                                openid = userentity.user_id;
                            }
                            break;
                        case loginbase.logintype.*:
                            {
                                //获取 access_token
                                var tokenentity = *.accesstoken(new *_accesstoken_requestentity()
                                {
                                    code = authorizeresult.code
                                });

                                //获取 user
                                var userentity = *.user(new *_user_requestentity()
                                {
                                    access_token = tokenentity.access_token
                                });

                                openid = userentity.user_id;
                            }
                            break;
                    }

                    //拿到登录标识
                    if (string.isnullorwhitespace(openid))
                    {
                        //to do
                    }
                }

            }
        }
    }
}

source

• https://github.com/netnr/netnr.login
• https://gitee.com/netnr/netnr.login