public override async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
{
// do something before the action executes
TokenResult = JsonConvert.DeserializeObject <OAuthAccessTokenResult>(context.HttpContext.Session.GetString("OAuthAccessTokenResult"));
var controller = context.RouteData.Values["controller"]?.ToString();
var actionName = context.RouteData.Values["action"]?.ToString();
if (controller?.ToUpper() == "SCHOOLBUS" && actionName?.ToUpper() != "REGISTER" && actionName?.ToUpper() != "SENDSMSCODE")
{
var result = await _schoolBusBusines.GetCardInfoByCodeAsync(TokenResult?.openid);
if (result == null || string.IsNullOrEmpty(result.fcode) || string.IsNullOrEmpty(result.wxpkid))
{
context.Result = new RedirectToActionResult("Register", "SchoolBus", null);
return;
}
}
await next();
// do something after the action executes
if (!(ViewData.Model is Base_JSSDKVD vd))
{
return;
}
var model = vd;
model.TokenResult = TokenResult;
model.PageRenderTime = DateTime.Now;
model.JsSdkUiPackage = JSSDKHelper.GetJsSdkUiPackage(Config.SenparcWeixinSetting.WeixinAppId,
Config.SenparcWeixinSetting.WeixinAppSecret,
Request.AbsoluteUri());
}
public ActionResult SignIn(string code, string state)
{
try
{
if (string.IsNullOrEmpty(code))
{
return(Redirect("/pages/error/error.html"));
}
OAuthAccessTokenResult result = OAuthApi.GetAccessToken(_appId, _secret, code);
if (result.errcode != 0)
{
return(Redirect("/pages/error/error.html"));
}
SysUserOpenId userOpenId = dbContext.Set <SysUserOpenId>().Where(x => x.OpenId == result.openid).FirstOrDefault();
if (userOpenId == null)
{
//逻辑1：跳转到绑定页面，适用于企业用户或已存在账号情况。
return(Redirect("/pages/account/bind.html?openid=" + result.openid));
//逻辑2：创建本地用户，适用公众网站，项目根据需要调整逻辑。
//var wxUser = OAuthApi.GetUserInfo(result.access_token, result.openid);
//SysUser user = new SysUser();
//user.UserId = Guid.NewGuid();
//user.UserName = wxUser.nickname;
//user.UserCode = "wx" + Guid.NewGuid().ToString("N").Substring(18);
//user.DepartmentId = new Guid("2379788E-45F0-417B-A103-0B6440A9D55D");
//dbContext.SysUser.Add(user);
//userOpenId = new SysUserOpenId();
//userOpenId.OpenId = result.openid;
//userOpenId.UserId = user.UserId;
//userOpenId.CreateTime = DateTime.Now;
//userOpenId.BindTime = DateTime.Now;
//dbContext.SysUserOpenId.Add(userOpenId);
//dbContext.SaveChanges();
}
SSOClient.SignIn(userOpenId.UserId.Value);
switch (state)
{
case "menu1":
return(Redirect("/weixin/templates/exampleone.html"));
case "menu2":
return(Redirect("/weixin/templates/exampletow.html"));
default:
return(Redirect("/weixin/home/index.html"));
}
}
catch (Exception ex)
{
LogHelper.SaveLog(ex);
return(Json(new { Code = 1, Msg = "服务器异常，请联系管理员！" }));
}
}
/// <summary>
/// 通过微信发送的code获取数据库用户信息
/// </summary>
/// <param name="code"></param>
public static DBUserInfo GetMPUserInfo(string code)
{
OAuthAccessTokenResult oauthTokenInfo =
OAuthApi.GetAccessToken(MPBasicSetting.AppID, MPBasicSetting.AppSecret, code);
return(DBUserInfo.GetUserDBInfo(oauthTokenInfo.openid));
}
public ActionResult UserInfoCallback(string code, string state, string returnUrl)
{
if (string.IsNullOrEmpty(code))
{
return(Content("您拒绝了授权！"));
}
if (state != Session["State"] as string)
{
return(Content("验证失败！请从正规途径进入！"));
}
OAuthAccessTokenResult result = OAuthApi.GetAccessToken(AppId, AppSecret, code);
OAuthUserInfo userInfo = OAuthApi.GetUserInfo(result.access_token, result.openid);
string ticket = string.Empty;
timestamp = JSSDKHelper.GetTimestamp();
nonceStr = JSSDKHelper.GetNoncestr();
JSSDKHelper jssdkhelper = new JSSDKHelper();
ticket = JsApiTicketContainer.TryGetJsApiTicket(AppId, AppSecret);
signature = JSSDKHelper.GetSignature(ticket, nonceStr, timestamp, Request.Url.AbsoluteUri.ToString());
ViewBag.signature = signature;
ViewBag.appid = AppId;
ViewBag.timestamp = timestamp;
ViewBag.noncestr = nonceStr;
return(View(userInfo));
}
#pragma warning disable CS1591 // 缺少对公共可见类型或成员的 XML 注释
public OAuthUserInfo GetUserInfoByCode(string code)
#pragma warning restore CS1591 // 缺少对公共可见类型或成员的 XML 注释
{
OAuthAccessTokenResult token = OAuthApi.GetAccessToken(Options.WeChatBaseOptions.AppId, Options.WeChatBaseOptions.Appsecret, code);
return(OAuthApi.GetUserInfo(token.access_token, token.openid));
}
// GET: OAuth2
public ActionResult Index()
{
//var code = Session["code"] as string;
var code = Request["code"];
if (string.IsNullOrEmpty(code))
{
string host = Request.Url.Host;
string path = Request.Path;
string state = "ROC" + DateTime.Now.Millisecond;
string redirect_uri = OAuthApi.GetAuthorizeUrl(Comm.WeixinData.AppId, string.Format(@"http://{0}{1}", host, path), state, OAuthScope.snsapi_base);
return(Redirect(redirect_uri));
}
else
{
//通过，用code换取access_token
OAuthAccessTokenResult result = null;
try
{
result = OAuthApi.GetAccessToken(WeixinData.AppId, WeixinData.AppSecret, code);
}
catch (Exception ex)
{
return(Content(ex.Message));
}
if (result.errcode != ReturnCode.请求成功)
{
return(Content("错误：" + result.errmsg));
}
OAuthUserInfo userInfo = OAuthApi.GetUserInfo(result.access_token, result.openid);
return(View(userInfo));
}
}
public ActionResult BaseCallback(string code, string state, string returnUrl)
{
try
{
if (string.IsNullOrEmpty(code))
{
return(base.RedirectError("您拒绝了授权！"));
}
if (state != (base.Session["State"] as string))
{
return(base.RedirectError("验证失败！请从正规途径进入！"));
}
OAuthAccessTokenResult result = OAuthApi.GetAccessToken(this.appId, this.secret, code, "authorization_code");
if (result.errcode != ReturnCode.请求成功)
{
return(base.RedirectError("错误：" + result.errmsg));
}
OAuthUserInfo model = OAuthApi.GetUserInfo(result.access_token, result.openid, Language.zh_CN);
base.Session["OAuthAccessTokenStartTime"] = DateTime.Now;
base.Session["OAuthAccessToken"] = result;
base.SetCookie("openid", result.openid);
base.SetCookie("wename", model.nickname);
base.SetCookie("headimg", model.headimgurl);
return(this.Redirect(returnUrl));
}catch (Exception ex)
{
return(Content(ex.Message));
}
}
/// <summary>
/// 通过code换取网页授权access_token和openid的返回数据
/// </summary>
/// <param name="code">code</param>
public async Task <WeiXinToken> GetOpenidAndAccessTokenFromCodeAsync(string userid, string code)
{
WeiXinToken token = null;
string redisKey = $"{RedisKey}:userid:{userid}";
string tokenString = RedisHelper.Database.StringGet(redisKey);
if (!string.IsNullOrWhiteSpace(tokenString))
{
var wexintoken = JsonConvert.DeserializeObject <WeiXinToken>(tokenString);
//失效时间大于当前时间
if (DateTime.Now >= token.expires_date)
{
return(token);
}
}
OAuthAccessTokenResult accessToken = OAuthApi.GetAccessToken(AppID, AppSecret, code);
if (accessToken.errcode == ReturnCode.请求成功)
{
token = new WeiXinToken();
token.access_token = accessToken.access_token;
token.create_date = DateTime.Now;
token.expires_in = accessToken.expires_in;
token.expires_date = token.create_date.AddSeconds(accessToken.expires_in);
token.openid = accessToken.openid;
token.refresh_token = accessToken.refresh_token;
token.scope = accessToken.scope;
token.unionid = accessToken.unionid;
RedisHelper.Database.StringSet(redisKey, token.access_token, new TimeSpan(1, 50, 0));
}
return(token);
}
public ActionResult Callback(string code, string state)
{
if (string.IsNullOrEmpty(code) || state != WeixinData.Token)
{
return(Content("验证授权失败!"));
}
//通过，用code换取access_token
OAuthAccessTokenResult result = null;
try
{
result = OAuthApi.GetAccessToken(Comm.WeixinData.AppId, Comm.WeixinData.AppSecret, code);
if (result.errcode != ReturnCode.请求成功)
{
return(Content("错误：" + result.errmsg));
}
OAuthUserInfo userInfo = OAuthApi.GetUserInfo(result.access_token, result.openid);
CustomerService cs = new CustomerService();
var customer = cs.AddCustomer(userInfo);
if (customer.IsManager)
{
Session["user"] = customer;
return(RedirectToAction("index", "admin"));
}
ViewBag.msg = "登录失败";
return(View("index"));
}
catch (Exception ex)
{
return(Content(ex.Message));
}
}
/// <summary>
/// 根据code获取用户信息,用户不关注时也能调用此接口;
/// https://open.weixin.qq.com/connect/oauth2/authorize?appid=appid&redirect_uri=redirect_url&response_type=code&amp;scope=snsapi_base&state=123#wechat_redirect";
/// 微信会有2此验证;
/// 可能抛出异常;
/// </summary>
/// <param name="code"></param>
public OAuthAccessTokenResult GetOpenIdInfoAccordCode(string code)
{
try
{
lock (map)
{
OAuthAccessTokenResult value = null;
bool result = map.TryGetValue(code, out value);
if (result)
{
// map.Remove(code); //第2次获取
return(value);
}
else
{
value = OAuthApi.GetAccessToken(Config.AppId, Config.AppSecret, code);
map[code] = value;
return(value);
}
}
}
catch (Exception exp)
{
//长度为28时，应该是 openid;
if (code.Length == 28)
{
return new OAuthAccessTokenResult {
openid = code
}
}
; //可能直接传入了 openid;
throw new Exception(exp.Message + string.Format("appId:{0},appSecret:{1}", Config.AppId, Config.AppSecret), exp);
}
}
protected void Page_Load(object sender, EventArgs e)
{
string uer_code = Request["code"].ToString(); //code作为换取access_token的票据，每次用户授权带上的code将不一样，code只能使用一次，5分钟未被使用自动过期。
//string uer_state = "oNOvqwo-qNYgd0d7bgV2rrn-s9Nc";// Request["state"].ToString();
string uer_state = Request["state"].ToString();
LogTextHelper.Info("传递进来的未知参数：" + uer_state);
OAuthAccessTokenResult accToken = OAuthApi.GetAccessToken(WeixinAppId, WeixinAppSecret, uer_code);
Response.Write("<br/>用户针对本公众号的唯一ID11" + accToken.access_token.ToString());
//OAuthUserInfo uerinfo = OAuthApi.GetUserInfo(accToken.access_token.ToString(),uer_state);
OAuthUserInfo uerinfo = OAuthApi.GetUserInfo(accToken.access_token.ToString(), uer_code);
Response.Write("</br>");
Response.Write("<b>用户的openid</b>:" + uerinfo.openid.ToString());
Response.Write("</br>");
Response.Write("<b>用户昵称</b>:" + uerinfo.nickname.ToString());
Response.Write("</br>");
Response.Write("<b>性别</b>:" + uerinfo.sex.ToString());
Response.Write("</br>");
Response.Write("<b>城市</b>:" + uerinfo.province.ToString());
Response.Write("</br>");
Response.Write("<img src=\"" + uerinfo.headimgurl.ToString() + "\"/ width=100 height=100 alt=\"" + uerinfo.nickname.ToString() + "\">");
Response.Write("</br>");
}
public ActionResult BaseCallback(string code, string state, string returnUrl)
{
try
{
if (string.IsNullOrEmpty(code))
{
return(base.RedirectError("您拒绝了授权！"));
}
if (state != (base.Session["State"] as string))
{
return(base.RedirectError("验证失败！请从正规途径进入！"));
}
OAuthAccessTokenResult result = OAuthApi.GetAccessToken(this.appId, this.secret, code, "authorization_code");
if (result.errcode != ReturnCode.请求成功)
{
return(base.RedirectError("错误：" + result.errmsg));
}
base.SetCookie("payopenid", result.openid);
return(this.Redirect(returnUrl));
}
catch (Exception ex)
{
return(Content(ex.Message));
}
}
//public ActionResult
public ActionResult Register(string code, string state)
{
WxPayAPI.Log.Info(this.GetType().ToString(), string.Format("---进入了用户信息回调(注册)---"));
WxPayAPI.Log.Info(this.GetType().ToString(), string.Format("---code:{0},state:{1}---", code, state));
//jsApiPay.GetOpenidAndAccessTokenFromCode(code);
if (string.IsNullOrEmpty(code))
{
//return Json(new ResultMessage() { Code = -1, Msg = "参数错误，请联系管理员！" });
return(Content("您拒绝了授权！"));
}
OAuthAccessTokenResult result = null;
//通过，用code换取access_token
try
{
//var model = Iwx_interfaceService.GetModel(new KodyCRM.DomainModels.Query.Admin.wx_interfaceQuery());
result = Senparc.Weixin.MP.AdvancedAPIs.OAuthApi.GetAccessToken(WxPayConfig.APPID, WxPayConfig.APPSECRET, code);
}
catch (Exception ex)
{
WxPayAPI.Log.Info(this.GetType().ToString(), string.Format("---openid:出错---"));
return(Content("您拒绝了授权！"));
}
if (result.errcode != ReturnCode.请求成功)
{
//return Json(new Result(-2, "请求失效,请重新进入购票"));
return(Content("错误：" + result.errmsg));
}
var openid = result.openid;
var user = IAccountService.GetByopenID(openid);
if (user == null)
{
int salerId = 0;
int.TryParse(state, out salerId);
OAuthUserInfo userInfo = Senparc.Weixin.MP.AdvancedAPIs.OAuthApi.GetUserInfo(result.access_token, result.openid);
user = new Account();
user.salerId = salerId;
user.gender = userInfo.sex;
user.name = userInfo.nickname;
user.openID = openid;
user.state = AccountStates.Normal;
user.submitTime = DateTime.Now;
//WxPayAPI.Log.Info(this.GetType().ToString(), string.Format("---头像:{0}---", userInfo.headimgurl));
user.photo = userInfo.headimgurl.Replace("/0", "/132");
if (IAccountService.Insert(user) > 0)
{
Session["openid"] = openid;
Session["accountId"] = user.accountId;
return(Redirect("/WeChatViews/JuMeiMallIndex.html?id=" + user.accountId));
}
}
else
{
return(Redirect("/WeChatViews/JuMeiMallIndex.html?id=" + user.accountId));
}
return(Content("授权失败！"));
}
/// <summary>
/// 版本回退
/// </summary>
/// <param name="access_token"></param>
/// <returns></returns>
public static WxJsonResult VersionBack(string access_token)
{
string url = string.Format(_versionBackUrl, access_token);
string result = HttpHelper.GetData(url);
OAuthAccessTokenResult model = GetResultModel <OAuthAccessTokenResult>(result);
return(model);
}
/// <summary>
/// OAuthScope.snsapi_userinfo方式回调
/// </summary>
/// <param name="code"></param>
/// <param name="state"></param>
/// <param name="returnUrl">用户最初尝试进入的页面</param>
/// <returns></returns>
public ActionResult UserInfoCallback(string code, string state, string returnUrl)
{
if (string.IsNullOrEmpty(code))
{
return(Content("您拒绝了授权！"));
}
if (state != Session["State"] as string)
{
//这里的state其实是会暴露给客户端的，验证能力很弱，这里只是演示一下，
//建议用完之后就清空，将其一次性使用
//实际上可以存任何想传递的数据，比如用户ID，并且需要结合例如下面的Session["OAuthAccessToken"]进行验证
return(Content("验证失败！请从正规途径进入！"));
}
OAuthAccessTokenResult result = null;
//通过，用code换取access_token
try
{
result = OAuthApi.GetAccessToken(appId, secret, code);
}
catch (Exception ex)
{
return(Content(ex.Message));
}
if (result.errcode != ReturnCode.请求成功)
{
return(Content("错误：" + result.errmsg));
}
//下面2个数据也可以自己封装成一个类，储存在数据库中（建议结合缓存）
//如果可以确保安全，可以将access_token存入用户的cookie中，每一个人的access_token是不一样的
Session["OAuthAccessTokenStartTime"] = DateTime.Now;
Session["OAuthAccessToken"] = result;
//因为第一步选择的是OAuthScope.snsapi_userinfo，这里可以进一步获取用户详细信息
try
{
OAuthUserInfo userInfo = OAuthApi.GetUserInfo(result.access_token, result.openid);
//WeixinTrace.SendLog("获取code成功", "actionUrl");
string data = "openid=" + userInfo.openid + "&nickname=" + userInfo.nickname + "&headimgurl=" + userInfo.headimgurl;
if (!string.IsNullOrEmpty(returnUrl))
{
if (returnUrl.IndexOf("?") == -1)
{
return(Redirect(returnUrl + "?" + data));
}
else
{
return(Redirect(returnUrl + "&" + data));
}
}
return(View(userInfo));
}
catch (ErrorJsonResultException ex)
{
return(Content(ex.Message));
}
}
/// <summary>
/// 从官方授权页面接收回调
/// </summary>
/// <param name="code"></param>
/// <param name="state"></param>
/// <param name="returnUrl"></param>
/// <returns></returns>
public ActionResult Callback(string code, string state, string returnUrl, string msg)
{
//if (state == null || state != Session["OAuthState"] as string)
//{
// return Content("非法进入！");
//}
if (string.IsNullOrEmpty(code))
{
return(Content("用户拒绝了授权"));
}
OAuthAccessTokenResult oauthResult = null;
try
{
oauthResult = Senparc.Weixin.MP.AdvancedAPIs.OAuthApi.GetAccessToken(Config.AppId, Config.AppSecret, code);
}
catch (ErrorJsonResultException ex)
{
//处理
throw;
}
var oauthAccessToken = oauthResult.access_token;
var openId = oauthResult.openid;
//var userInfo = UserApi.Info()
var userInfo = OAuthApi.GetUserInfo(oauthAccessToken, openId);
//更多的业务逻辑
//进行登录
System.Web.Security.FormsAuthentication.SetAuthCookie(openId, false);
////用户注册
//if (!是否用户已注册)
//{
// //进行注册
// var userInfo = 从数据库获取();
//}
//else
//{
// var userInfo = OAuthApi.GetUserInfo(oauthAccessToken, openId);
//}
ViewData["Msg"] = msg;
if (!string.IsNullOrEmpty(returnUrl))
{
return(Redirect(returnUrl));
}
else
{
return(View(userInfo));
}
}
/// <summary>
/// 小程序审核撤回
/// 单个帐号每天审核撤回次数最多不超过1次，一个月不超过10次。
/// </summary>
/// <param name="access_token">请使用第三方平台获取到的该小程序授权的authorizer_access_token</param>
/// <returns></returns>
public static OAuthAccessTokenResult UndocodeAudit(string access_token)
{
string url = string.Format(_undocodeAuditUrl, access_token);
string result = HttpHelper.GetData(url);
OAuthAccessTokenResult model = GetResultModel <OAuthAccessTokenResult>(result);
return(model);
}
/// <summary>
/// 提交小程序代码审核
/// </summary>
/// <param name="access_token">请使用第三方平台获取到的该小程序授权的authorizer_access_token</param>
/// <returns></returns>
public static OAuthAccessTokenResult SubmitAudit(string access_token, object data)
{
string url = string.Format(_submitAuditUrl, access_token);
string dataJson = JsonConvert.SerializeObject(data);
string result = HttpHelper.DoPostJson(url, dataJson);
OAuthAccessTokenResult model = GetResultModel <OAuthAccessTokenResult>(result);
return(model);
}
/// <summary>
/// 用户授权回调
/// </summary>
/// <param name="code"></param>
/// <param name="state"></param>
/// <param name="appId"></param>
/// <returns></returns>
public ActionResult UserInfoCallback(string code, string state, string appId)
{
if (string.IsNullOrEmpty(code))
{
return(Content("您拒绝了授权！"));
}
if (state != "wofweixin")
{
return(Content("验证失败！请从正规途径进入！"));
}
OAuthAccessTokenResult result = null;
//通过，用code换取access_token
try
{
var componentAccessToken = ComponentContainer.GetComponentAccessToken(component_AppId);
result = OAuthApi.GetAccessToken(appId, component_AppId, componentAccessToken, code);
}
catch (Exception ex)
{
return(Content("用code换取accesstoken" + ex.Message));
}
if (result.errcode != ReturnCode.请求成功)
{
return(Content("错误：" + result.errmsg));
}
//存储或更新用户的访问令牌
_userGenerator.UpdateOAuthAccessToken(new Models.UserOAuthAccessToken
{
OpenId = result.openid,
StartTime = DateTime.Now,
AccessToken = result.access_token,
});
try
{
OAuthUserInfo userInfo = OAuthApi.GetUserInfo(result.access_token, result.openid);
//存储用户的微信资料
_userGenerator.CreateUser(new Models.UserInfo
{
OpenId = userInfo.openid,
UnionId = userInfo.unionid,
NickName = userInfo.nickname,
Gender = userInfo.sex.ToString(),
Province = userInfo.province,
City = userInfo.city,
County = userInfo.country,
Portrait = userInfo.headimgurl,
});
return(View(userInfo));
}
catch (ErrorJsonResultException ex)
{
return(Content("获取用户信息" + ex.Message));
}
}
/// <summary>
/// OAuth验证,第三方网页时授权
/// </summary>
/// <param name="code"></param>
/// <param name="state"></param>
/// <param name="returnUrl"></param>
/// <returns></returns>
public ActionResult OAuth(string code, string state, string returnUrl)
{
if (string.IsNullOrEmpty(code))
{
return(Content("您拒绝了授权！"));
}
// if (state != HttpContext.Session.GetString("State"))
// {
// //这里的state其实是会暴露给客户端的，验证能力很弱，这里只是演示一下，
// //建议用完之后就清空，将其一次性使用
// //实际上可以存任何想传递的数据，比如用户ID，并且需要结合例如下面的Session["OAuthAccessToken"]进行验证
// return Content("验证失败！请从正规途径进入！");
// }
OAuthAccessTokenResult result = null;
//通过，用code换取access_token
try
{
Log.Debug("code值", code, null);
result = OAuthApi.GetAccessToken(AppId, AppSecret, code);
Log.Info("openid", result.openid, null);
}
catch (Exception ex)
{
Log.Debug("1.发生错误啦~~~", ex.Message, null);
return(Content(ex.Message));
}
if (result.errcode != ReturnCode.请求成功)
{
Log.Debug("result.errcode", result.errcode.ToString(), null);
return(Content("错误：" + result.errmsg));
}
//下面2个数据也可以自己封装成一个类，储存在数据库中（建议结合缓存）
//如果可以确保安全，可以将access_token存入用户的cookie中，每一个人的access_token是不一样的
// HttpContext.Session.SetString("OAuthAccessTokenStartTime", DateTime.Now.ToString());
// HttpContext.Session.SetString("OAuthAccessToken", result.ToJson());
//因为第一步选择的是OAuthScope.snsapi_userinfo，这里可以进一步获取用户详细信息
try
{
if (!string.IsNullOrEmpty(returnUrl))
{
return(Redirect(returnUrl));
}
//这里获取openid就结束了。OAuthScope.snsapi_base 模式就结束了。
//保存到数据库中吧。
return(View());
}
catch (ErrorJsonResultException ex)
{
return(Content(ex.Message));
}
}
/// <summary>
/// 查询最新一次提交的审核状态（仅供第三方代小程序调用）
/// </summary>
/// <param name="access_token">请使用第三方平台获取到的该小程序授权的authorizer_access_token</param>
/// <returns></returns>
public static OAuthAccessTokenResult GetLatestAuditstatus(string access_token)
{
string url = string.Format(_getLatestAuditstatusUrl, access_token);
string result = HttpHelper.GetData(url);
OAuthAccessTokenResult model = GetResultModel <OAuthAccessTokenResult>(result);
return(model);
}
/// <summary>
/// 保存OAuthAccessTokenResult Session值
/// </summary>
/// <param name="result"></param>
public void SetOAuthAccessToken(OAuthAccessTokenResult result)
{
//下面2个数据也可以自己封装成一个类，储存在数据库中（建议结合缓存）
//如果可以确保安全，可以将access_token存入用户的cookie中，每一个人的access_token是不一样的
Session["OAuthAccessTokenStartTime"] = SystemTime.Now;
Session["OAuthAccessToken"] = result;
Session.Timeout = 45;
}
/// <summary>
/// 提交小程序代码
/// </summary>
/// <param name="componentAccessToken">已授权用户的access_token</param>
/// <param name="ext_json"></param>
/// <returns></returns>
public static OAuthAccessTokenResult Commit(string componentAccessToken, CommitModel ext_json)
{
string url = string.Format(_commitUrl, componentAccessToken);
string dataJson = JsonConvert.SerializeObject(ext_json);
string result = HttpHelper.DoPostJson(url, dataJson);
OAuthAccessTokenResult model = GetResultModel <OAuthAccessTokenResult>(result);
return(model);
}
/// <summary>
/// OAuthScope.snsapi_userinfo方式回调
/// </summary>
/// <param name="code"></param>
/// <param name="state"></param>
/// <param name="returnUrl">用户最初尝试进入的页面</param>
/// <returns></returns>
public ActionResult UserInfoCallback(string code, string state, string returnUrl)
{
if (string.IsNullOrEmpty(code))
{
return(Content("您拒绝了授权！"));
}
if (state != Session["State"] as string)
{
//这里的state其实是会暴露给客户端的，验证能力很弱，这里只是演示一下，
//建议用完之后就清空，将其一次性使用
//实际上可以存任何想传递的数据，比如用户ID，并且需要结合例如下面的Session["OAuthAccessToken"]进行验证
return(Content("验证失败！请从正规途径进入！"));
}
OAuthAccessTokenResult result = null;
//通过，用code换取access_token
try
{
result = OAuthApi.GetAccessToken(appId, appSecret, code);
}
catch (Exception ex)
{
return(Content(ex.Message));
}
if (result.errcode != ReturnCode.请求成功)
{
return(Content("错误：" + result.errmsg));
}
SetOAuthAccessToken(result);
//因为第一步选择的是OAuthScope.snsapi_userinfo，这里可以进一步获取用户详细信息
try
{
OAuthUserInfo userInfo = OAuthApi.GetUserInfo(result.access_token, result.openid);
SetWxUserInfo(userInfo);
SetWxUserOpenId(result.openid);
returnUrl = WebHelper.HtmlDecode(returnUrl);
if (!string.IsNullOrEmpty(returnUrl))
{
if (returnUrl.IndexOf("?") > 0)
{
returnUrl = returnUrl + "&openid=" + result.openid;
}
else
{
returnUrl = returnUrl + "?openid=" + result.openid;
}
return(Redirect(returnUrl));
}
return(View(userInfo));
}
catch (ErrorJsonResultException ex)
{
return(Content(ex.Message));
}
}
public ActionResult Login()
{
string code = Request.QueryString["code"];
string state = Request.QueryString["state"];
string s = Request.QueryString["s"];
if (!IsLogin)
{
OAuthAccessTokenResult result = OAuthApi.GetAccessToken(tenPayV3Info.AppId, tenPayV3Info.AppSecret, code);
if (result.errcode == Senparc.Weixin.ReturnCode.请求成功)
{
string openid = result.openid;
UserService x_userService = new UserService();
var item = x_userService.Get(a => a.OpenId == openid).FirstOrDefault();
if (item != null)
{
if (item.IsValid == 1)
{
Authentication.Instance.SetAuth(item, true);
}
else
{
return(Redirect("/"));
}
}
else //获取用户的信息
{
OAuthUserInfo wxUser = OAuthApi.GetUserInfo(result.access_token, code);
if (wxUser != null)
{
UserInfo uInfo = new UserInfo()
{
IsValid = 1,
CreateTime = DateTime.Now,
//Lastlogintime = DateTime.Now,
NickName = wxUser.nickname,
OpenId = wxUser.openid,
HeadImage = wxUser.headimgurl
};
uInfo.ID = Convert.ToInt32(x_userService.Insert(uInfo));
Authentication.Instance.SetAuth(uInfo, true);
}
else
{
return(Redirect("/"));
}
}
}
}
string url = "/";
if (!string.IsNullOrEmpty(s))
{
url = s;
}
return(Redirect(url));
}
/// <summary>
/// code 换取 session_key
/// </summary>
/// <param name="appid">小程序的AppID</param>
/// <param name="js_code">登录时获取的 code</param>
/// <param name="component_appid">第三方平台appid</param>
/// <param name="component_access_token">第三方平台的component_access_token</param>
/// <returns></returns>
public static OAuthAccessTokenResult GetSessionKey(string appid, string js_code, string componetappid, string componentaccesstoken)
{
string url = string.Format(_getSessionKeyUrl, appid, js_code, componetappid, componentaccesstoken);
string result = HttpHelper.GetData(url);
OAuthAccessTokenResult model = GetResultModel <OAuthAccessTokenResult>(result);
return(model);
}
/// <summary>
/// 授权
/// </summary>
/// <param name="code"></param>
/// <param name="returnUrl"></param>
public string Authorize(string code, string returnUrl)
{
OAuthAccessTokenResult oAuthAccessTokenResult = null;
oAuthAccessTokenResult = OAuthApi.GetAccessToken(
WechatAppSettings.AppId,
WechatAppSettings.CorpSecret,
code);
if (oAuthAccessTokenResult == null)
{
throw new Exception("错误消息:oAuthAccessTokenResult为空");
}
if (oAuthAccessTokenResult != null &&
oAuthAccessTokenResult.errcode
!= ReturnCode.请求成功)
{
throw new Exception("错误消息:" + oAuthAccessTokenResult.errmsg);
}
var userInfo = OAuthApi.GetUserInfo(
oAuthAccessTokenResult.access_token,
oAuthAccessTokenResult.openid
);
var item = _baseRepository.GetAll().FirstOrDefault(x => x
.OpenId == userInfo.openid);
if (item == null)
{
var model = new WeiXinUserInfo
{
City = userInfo.city,
Country = userInfo.country,
HeadImgUrl = userInfo.headimgurl,
NickName = userInfo.nickname,
OpenId = userInfo.openid,
Province = userInfo.province,
Sex = userInfo.sex.ToString(),
UnionId = userInfo.unionid
};
_baseRepository.Insert(model);
}
if (returnUrl.Contains("?"))
{
returnUrl = returnUrl + "&access_token=" + oAuthAccessTokenResult.access_token + "&openid=" + oAuthAccessTokenResult.openid;
}
else
{
returnUrl = returnUrl + "?access_token=" + oAuthAccessTokenResult.access_token + "&openid=" + oAuthAccessTokenResult.openid;
}
return(returnUrl);
}
/// <summary>
/// 添加体验者
/// </summary>
/// <param name="access_token">请使用第三方平台获取到的该小程序授权的authorizer_access_token</param>
/// <param name="wechatid">微信号</param>
/// <returns></returns>
public static OAuthAccessTokenResult BindTester(string access_token, string wechatid)
{
string url = string.Format(_bindTesterUrl, access_token);
var data = new { wechatid = wechatid };
string dataJson = JsonConvert.SerializeObject(data);
string result = HttpHelper.DoPostJson(url, dataJson);
OAuthAccessTokenResult model = GetResultModel <OAuthAccessTokenResult>(result);
return(model);
}
/// <summary>
/// 解绑平台与小程序
/// </summary>
/// <param name="access_token">请使用第三方平台获取到的该小程序授权的authorizer_access_token</param>
/// <returns></returns>
public static OAuthAccessTokenResult Unbind(string access_token, string appid, string open_appid)
{
string url = string.Format(_unbindUrl, access_token);
var data = new { appid = appid, open_appid = open_appid };
string dataJson = JsonConvert.SerializeObject(data);
string result = HttpHelper.DoPostJson(url, dataJson);
OAuthAccessTokenResult model = GetResultModel <OAuthAccessTokenResult>(result);
return(model);
}
/// <summary>
/// 获取体验者列表
/// </summary>
/// <param name="access_token">请使用第三方平台获取到的该小程序授权的authorizer_access_token</param>
/// <returns></returns>
public static OAuthAccessTokenResult GetMemberauth(string access_token)
{
string url = string.Format(_getMemberauthUrl, access_token);
var data = new { action = "get_experiencer" };
string dataJson = JsonConvert.SerializeObject(data);
string result = HttpHelper.DoPostJson(url, dataJson);
OAuthAccessTokenResult model = GetResultModel <OAuthAccessTokenResult>(result);
return(model);
}
