public ActionResult BaseCallback(string code, string state)
{
if (string.IsNullOrEmpty(code))
{
return(Content("您拒绝了授权！"));
}
if (state != "JeffreySu")
{
//这里的state其实是会暴露给客户端的，验证能力很弱，这里只是演示一下
//实际上可以存任何想传递的数据，比如用户ID，并且需要结合例如下面的Session["OAuthAccessToken"]进行验证
return(Content("验证失败！请从正规途径进入！"));
}
//通过，用code换取access_token
var result = OAuthApi.GetAccessToken(appId, secret, code);
if (result.errcode != ReturnCode.请求成功)
{
return(Content("错误：" + result.errmsg));
}
//下面2个数据也可以自己封装成一个类，储存在数据库中（建议结合缓存）
//如果可以确保安全，可以将access_token存入用户的cookie中，每一个人的access_token是不一样的
Session["OAuthAccessTokenStartTime"] = DateTime.Now;
Session["OAuthAccessToken"] = result;
//因为这里还不确定用户是否关注本微信，所以只能试探性地获取一下
OAuthUserInfo userInfo = null;
try
{
//已关注，可以得到详细信息
userInfo = OAuthApi.GetUserInfo(result.access_token, result.openid);
ViewData["ByBase"] = true;
return(View("UserInfoCallback", userInfo));
}
catch (ErrorJsonResultException ex)
{
//未关注，只能授权，无法得到详细信息
//这里的 ex.JsonResult 可能为："{\"errcode\":40003,\"errmsg\":\"invalid openid\"}"
return(Content("用户已授权，授权Token：" + result));
}
}
/// <summary>
/// OAuthScope.snsapi_userinfo方式回调
/// </summary>
/// <param name="code"></param>
/// <param name="returnUrl">用户最初尝试进入的页面</param>
/// <returns></returns>
public ActionResult UserInfoCallback(string code, string returnUrl)
{
if (string.IsNullOrEmpty(code))
{
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));
}
//下面2个数据也可以自己封装成一个类，储存在数据库中（建议结合缓存）
//如果可以确保安全，可以将access_token存入用户的cookie中，每一个人的access_token是不一样的
HttpContext.Session.SetString("OAuthAccessTokenStartTime", SystemTime.Now.ToString());
HttpContext.Session.SetString("OAuthAccessToken", result.ToJson());
//因为第一步选择的是OAuthScope.snsapi_userinfo，这里可以进一步获取用户详细信息
try
{
if (!string.IsNullOrEmpty(returnUrl))
{
return(Redirect(returnUrl));
}
OAuthUserInfo userInfo = OAuthApi.GetUserInfo(result.access_token, result.openid);
return(View(userInfo));
}
catch (ErrorJsonResultException ex)
{
return(Content(ex.Message));
}
}
//写回调函数，相当于用户点击授权之后返回的一个授权的凭证，状态码以及最初请求的第三方url
public ActionResult CallBack(string code, string state, string returnUrl)
{
//比较state是否相同（相当于验证码的比较）
if (Session["state"]?.ToString() != state)
{
Session["state"] = null;
return(Content("验证失败"));
}
Session["state"] = null;
//判断凭证code
if (string.IsNullOrEmpty(code))
{
//返回授权页面
return(Content("你拒绝了授权"));
}
//如果code存在则需要拿code换取oauthAccessToken 返回一个对象包含有oauthAccessToken
var oauthAccessToken = OAuthApi.GetAccessToken(appID, appsecret, code);
if (oauthAccessToken.errcode != Senparc.Weixin.ReturnCode.请求成功)
{
return(Content($"错误消息：{oauthAccessToken.errmsg}"));
}
Session["oauthAccessToken"] = oauthAccessToken;//保存共供过滤器判断
try
{
OAuthUserInfo usrInfo = OAuthApi.GetUserInfo(oauthAccessToken.access_token, oauthAccessToken.openid);
Session["usrInfo"] = usrInfo;
return(Redirect(returnUrl));
}
catch (Exception)
{
//如果获取用户信息异常，则需要用户重新请求授权页面
var redirect_uri = $"http://wx.caishengjian.xin{Url.Action("CallBack", new { returnUrl })}";
//state可自定义，相当于一个验证码
state = "wx" + DateTime.Now.Millisecond;
//把state保存下来
Session["state"] = state; //验证比较之后清空
var redirect = OAuthApi.GetAuthorizeUrl(appID, redirect_uri, state, Senparc.Weixin.MP.OAuthScope.snsapi_userinfo); //静默登录只能获得openid
//此处授权验证地址是内置好的，只需要跳转请求即可
return(Redirect(redirect)); //用户可以点击授权登录
}
}
//写回调函数 相当于用户点击同意授权之后，返回的一个授权凭证，还有状态码，以及最初请求的第三方url
public ActionResult CallBack(string code, string state, string returnUrl)
{
//1.比较state 是否相同，相当于验证码的比较
if (Session["state"]?.ToString() != state)
{
Session["state"] = null;
return(Content("验证失败"));
}
Session["state"] = null;
//判断凭证code
if (string.IsNullOrEmpty(code))
{
//返回授权页面 获取给出提示
return(Content("您拒绝授权"));
}
//如果code 存在 则需要拿code换 accessToken 返回的是一个对象 包含有accesstoken
var oauthAccessToken = OAuthApi.GetAccessToken(appID, appsecret, code);
if (oauthAccessToken.errcode != Senparc.Weixin.ReturnCode.请求成功)
{
return(Content($"错误消息：{oauthAccessToken.errmsg}"));
}
Session["oauthAccessToken"] = oauthAccessToken;//保存起来 供过滤器判断
try
{
OAuthUserInfo userInfo = OAuthApi.GetUserInfo(oauthAccessToken.access_token, oauthAccessToken.openid);
Session["userInfo"] = userInfo;
return(Redirect(returnUrl));
}
catch
{
var redirect_uri = $"http://wx.lingnian.xin{Url.Action("CallBack", new { returnUrl })}";
//state可以由开发者自己定义，作用就相当于一个验证码
string statee = "wx" + DateTime.Now.Millisecond;
//把拼接好的state保存下来
Session["state"] = statee;//一旦验证比较以后，需要对session中的state session["state"]=null;
string redirect = OAuthApi.GetAuthorizeUrl(appID, returnUrl, state, Senparc.Weixin.MP.OAuthScope.snsapi_userinfo);
//注意 该处的授权验证地址 是内置好的， 只需要跳转请求即可
return(Redirect(redirect));
}
}
// GET: Order
public ActionResult Index()
{
string[] id = Request["id"].Split(',');//
foreach (var item in id)
{
var shopOrder = ShopCartService.GetEntities(x => x.Cid == item);
}
ViewBag.id = id;
ViewBag.pro = proService;
ViewBag.shopcartService = ShopCartService;
OAuthUserInfo userInfo = Session["userInfo"] as OAuthUserInfo; //获取用户的信息
string cid = userInfo.openid; //获取用户的openid
var address = addressService.GetEntity(x => x.IsDefault == true && x.cid == cid); //查找出关于用户的默认收货底座
ViewBag.name = address.name; //把收货人传到前台
ViewBag.address = address.address1; //把收货地址传到前台
ViewBag.tel = address.tel;
return(View());
}
/// <summary>
/// 获取用户信息
/// </summary>
/// <param name="cusid"></param>
public void addCus(OAuthUserInfo cusid)
{
Customer cust = new Customer();
cust.OpenId = cusid.openid;
cust.Name = cusid.nickname;
cust.Img = cusid.headimgurl;
cust.Address = cusid.city;
cust.CreateTime = DateTime.Now;
if (CustomerService.GetEntities(b => b.OpenId == cusid.openid).Count() <= 0)
{
CustomerService.Add(cust);
}
else if (CustomerService.GetEntities(b => b.OpenId == cusid.openid && b.Name == cusid.nickname && b.Img == cusid.headimgurl).Count() <= 0)
{
CustomerService.Modity(cust);
}
//Session["usid"]=CustomerService.GetEntity(b=>b.OpenId==cust.OpenId).Id;//当前登录用户id
}
public void ShouldCreateUserWithOAuth()
{
var oAuthUserInfo = new OAuthUserInfo
{
Email = "*****@*****.**",
Name = "J",
OAuthProvider = "SomeOAuth",
OAuthUsername = "******",
OAuthProviderId = "123"
};
var user = _factory.Create(oAuthUserInfo);
Assert.Equal(oAuthUserInfo.Name, user.Name);
Assert.Equal(oAuthUserInfo.Email, user.Email);
Assert.True(user.OAuthUser);
Assert.Equal(oAuthUserInfo.OAuthProvider, user.OAuthProvider);
Assert.True(string.IsNullOrEmpty(user.PasswordHash));
Assert.Equal(UserRoles.BasicRole, user.Roles);
}
public void addCus(OAuthUserInfo cus)
{
HomeViewModel homeViewModel = new HomeViewModel();
Customer cust = new Customer();
cust.OpenId = cus.openid;
cust.UImg = cus.headimgurl;
cust.Name = cus.nickname;
cust.CreateTime = DateTime.Now;
if (CustomerService.GetCount(n => n.OpenId == cus.openid) < 1)
{
CustomerService.Add(cust);
}
else if (CustomerService.GetCount(n => n.UImg == cus.headimgurl && n.Name == cus.nickname) < 1)
{
cust.ID = CustomerService.GetEntities(c => c.OpenId == cust.OpenId).First().ID;
CustomerService.Add(cust);
}
Session["openid"] = cus.openid;
}
private static UserInfoEntity TransformToUser(OAuthUserInfo wxUser)
{
var user = new UserInfoEntity()
{
openid = wxUser.openid,
// groupid = wxUser.groupid,
headimgurl = wxUser.headimgurl,
// language = wxUser.language,
province = wxUser.province,
// remark = wxUser.remark,
// subscribe = wxUser.subscribe,
// subscribe_time = wxUser.subscribe_time,
nickname = wxUser.nickname,
sex = wxUser.sex,
city = wxUser.country,
country = wxUser.country
};
return(user);
}
/// <summary>
/// OAuthScope.snsapi_userinfo方式回调
/// </summary>
/// <param name="code"></param>
/// <param name="state"></param>
/// <returns></returns>
public ActionResult UserInfoCallback(string code, string state)
{
if (string.IsNullOrEmpty(code))
{
return(Content("您拒绝了授权！"));
}
if (state != "JeffreySu")
{
//这里的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);
return(View(userInfo));
}
catch (ErrorJsonResultException ex) {
return(Content(ex.Message));
}
}
/// <summary>
/// 微信公众号引导页 使用微信SNSToken获取微信用户信息，包括用户UnionID信息
/// </summary>
/// <returns>成功时，返回带有用户信息的URL并重定向</returns>
public ActionResult GetUserInfo2()
{
string code = Request.QueryString["code"];
string state = Request.QueryString["state"];
try
{
if (!string.IsNullOrEmpty(code) && !string.IsNullOrEmpty(state))
{
WXHelper WXHelper = new WXHelper();
string strGetSnsToken = WXHelper.Request(string.Format("https://api.weixin.qq.com/sns/oauth2/access_token?appid={0}&secret={1}&code={2}&grant_type=authorization_code", appId, secret, code), "", "GET");
JObject jo1 = JsonConvert.DeserializeObject <JObject>(strGetSnsToken);
string strResult = WXHelper.Request(string.Format("https://api.weixin.qq.com/sns/userinfo?access_token={0}&openid={1}&lang=zh_CN ", jo1["access_token"].ToString(), jo1["openid"].ToString()), "", "GET");
OAuthUserInfo userInfo = JsonConvert.DeserializeObject <OAuthUserInfo>(strResult);
if (userInfo != null)
{
object objUrl = CacheHelper.GetCache(state);
if (objUrl != null)
{
UriBuilder URL = new UriBuilder(objUrl.ToString());
string directUrl = URL.ToString();
directUrl += string.Format("?openid={0}&nickname={1}&sex={2}&province={3}&city={4}&country={5}&headimgurl={6}&unionid={7}",
userInfo.openid, userInfo.nickname, userInfo.sex, userInfo.province, userInfo.city, userInfo.country, userInfo.headimgurl, userInfo.unionid);
Response.Redirect(directUrl);
}
}
}
else
{
ViewData["errmsg"] = "用户code获取失败！";
}
}
catch (Exception ex)
{
ViewData["errmsg"] = ex.Message;
}
return(View());
}
public OAuthUserInfo GetUserInfo(System.Collections.Specialized.NameValueCollection queryString)
{
var config = WeiboCore.GetConfig();
var oatuth = new NetDimension.Weibo.OAuth(config.AppKey, config.AppSecret, ReturnUrl);
NetDimension.Weibo.Client client = new NetDimension.Weibo.Client(oatuth);
var code = queryString["code"];
var accessToken = oatuth.GetAccessTokenByAuthorizationCode(code);
OAuthUserInfo userInfo = null;
if (oatuth != null)
{
userInfo = new OAuthUserInfo();
userInfo.OpenId = client.API.Entity.Account.GetUID();
var user = client.API.Entity.Users.Show(userInfo.OpenId);
userInfo.NickName = userInfo.RealName = user.Name;
userInfo.IsMale = user.Gender == "m";
}
return(userInfo);
}
public ActionResult Index()
{
OAuthUserInfo userInfo = Session["userInfo"] as OAuthUserInfo;
Session["cid"] = userInfo.openid;
var shopcart = shopCartService.GetEntities(x => x.Cid == userInfo.openid);
ViewBag.count = shopcart.Count();
//查询banner
var GetBanner = BannerService.GetEntities(x => true);
ViewBag.Banner = GetBanner.ToList();
//查询滚动新闻
var GetShowNews = ShowNewsService.GetEntities(x => true);
ViewBag.ShowNews = GetShowNews.ToList();
ViewBag.show11 = GetShowNews.Count();
Session["count"] = shopcart.Count();
Session["shownews"] = GetShowNews.Count();
return(View());
}
public ActionResult JoinOrder(string remark, string youfei, string pay)
{
OAuthUserInfo userInfo = Session["userInfo"] as OAuthUserInfo; //获取用户的信息
string cid = userInfo.openid; //获取用户的openid
SqlParameter Uid = new SqlParameter("@user_id", cid);
SqlParameter totalPrice = new SqlParameter("@total_Price", pay);
SqlParameter expressPrice = new SqlParameter("@expressPrice", youfei);
SqlParameter Remark = new SqlParameter("@ReMark", remark);
SqlParameter msg = new SqlParameter()
{
ParameterName = "@msg",
SqlDbType = System.Data.SqlDbType.NVarChar,
Size = 50,
Direction = System.Data.ParameterDirection.Output
};
//这里需要注意：利用这个方法的时候里面的@字段，需要与存储过程里面的字段保持一致，不然会出现：“参数只能是数据库参数和值的错误”
/* 如果存储过程里面有输出参数，同样需要参数化，只是参数化的方法不一样，需要指明参数名称、参数类型、类型的大小、描述：这个描述说明这个是一个输出的参数*/
addressService.ExecuteCommand("exec proInsertOrder @user_id,@total_Price,@expressPrice,@ReMark,@msg output", Uid, totalPrice, expressPrice, Remark, msg);
return(Content(msg.Value.ToString()));
}
public void AddCustomer(OAuthUserInfo customer)
{
Customer cust = new Customer();
cust.OpenId = customer.openid;
cust.Photo = customer.headimgurl;
cust.Name = customer.nickname;
cust.Address = customer.city;
cust.CreateTime = DateTime.Now;
cust.Role = "普通用户";
if (CustomerService.GetCount(n => n.OpenId == customer.openid) < 1)
{
CustomerService.Add(cust);
}
else if (CustomerService.GetCount(n => n.Photo == customer.headimgurl) < 1)
{
cust.Id = CustomerService.GetEntities(n => n.OpenId == customer.openid).First().Id;
CustomerService.Add(cust);
}
Session["openid"] = customer.openid;
}
public ActionResult UserInfoCallback(string code, string state, string returnUrl)
{
if (string.IsNullOrEmpty(code))
{
return(base.Content("您拒绝了授权！"));
}
if (state != (base.Session["State"] as string))
{
return(base.Content("验证失败！请从正规途径进入！"));
}
OAuthAccessTokenResult result = null;
try
{
result = OAuthApi.GetAccessToken(this.appId, this.secret, code, "authorization_code");
}
catch (Exception exception)
{
return(base.Content(exception.Message));
}
if (result.errcode != ReturnCode.请求成功)
{
return(base.Content("错误：" + result.errmsg));
}
base.Session["OAuthAccessTokenStartTime"] = DateTime.Now;
base.Session["OAuthAccessToken"] = result;
try
{
if (!string.IsNullOrEmpty(returnUrl))
{
return(this.Redirect(returnUrl));
}
OAuthUserInfo model = OAuthApi.GetUserInfo(result.access_token, result.openid, Language.zh_CN);
return(base.View(model));
}
catch (ErrorJsonResultException exception2)
{
return(base.Content(exception2.Message));
}
}
//写回调函数
public ActionResult CallBack(string code, string state, string returnUrl)
{
//判断验证码是不是正确 //将获取到的自定义秘钥state与保存的session["state"]自定义秘钥比较验证
if (Session["state"]?.ToString() != state)
{
Session["state"] = null;
return(Content("请从正确渠道进入网站"));
}
Session["state"] = null;
//判断code
if (string.IsNullOrEmpty(code))
{
//如果没有code返回授权界面
return(RedirectToAction("index"));
}
var accessToken = OAuthApi.GetAccessToken(appID, appsecret, code); //获取token, 这里返回的是一个对象
if (accessToken.errcode != ReturnCode.请求成功) //returncode 需要引用命名空间
{
//需要重新定位到授权页面
return(Content($"错误消息:{accessToken.errmsg}"));
}
Session["oauthAccessToken"] = accessToken;//保存起来供过滤器判断
try
{
OAuthUserInfo userInfo = OAuthApi.GetUserInfo(accessToken.access_token, accessToken.openid);
Session["userInfo"] = userInfo;
return(Redirect(returnUrl));
}
catch (Exception)
{
//如果没有获取到用户信息,则需要进入授权界面
var redirect_uri = $"{Domin}{Url.Action("CallBack", new { returnUrl })}";
//随机数,加强回调请求的安全,相当于验证码
string state1 = "wx" + DateTime.Now.Millisecond;
Session["state"] = state1;
string rdeirect = OAuthApi.GetAuthorizeUrl(appID, redirect_uri, state1, Senparc.Weixin.MP.OAuthScope.snsapi_userinfo);
return(Redirect(rdeirect));
}
}
public async Task <IActionResult> Register(RegisterModel user)
{
var res = new RegisVD();
if (ModelState.IsValid)
{
#if DEBUG
user.wxid = Openid;
user.userName = Nickname;
#else
OAuthUserInfo userInfo = OAuthApi.GetUserInfo(TokenResult.access_token, TokenResult.openid);
user.wxid = userInfo.openid;
user.userName = userInfo.nickname;
#endif
res = await _schoolBusBusines.DoRegisterAsync(user);
}
else
{
res.msg = GetModelStateError();
}
return(Json(res));
}
private User CreateUser(OAuthUserInfo userInfo)
{
var user = _userService.GetUserByOpenId(userInfo.openid);
if (user == null)
{
Logger.Info("用户不存在");
user = new User()
{
Username = userInfo.nickname,
OpenId = userInfo.openid,
AuthType = AuthType.WeiXin,
Gender = userInfo.sex.ToString(),
Province = userInfo.province,
Country = userInfo.country,
City = userInfo.city,
ImgUrl = userInfo.headimgurl,
Active = true
};
_userDbService.InsertUser(user);
var checkuser = _userDbService.GetUserByOpenId(user.OpenId);
_payMeentDbService.CheckAndCreate(checkuser.Id);
}
else
{
Logger.Info("更新微信登录信息：" + userInfo.nickname);
_userDbService.UpdateUserForWx(user.OpenId, userInfo);
}
//if (!user.IsRegistered())
//{
// var role = _userService.GetUserRoleBySystemName(SystemUserRoleNames.Registered);
// user.UserRoles.Add(role);
// _userService.UpdateUser(user);
//}
return(user);
}
public OAuthUserInfo GetUserInfo(NameValueCollection queryString)
{
OAuthUserInfo oAuthUserInfo = new OAuthUserInfo();
string empty = string.Empty;
string item = string.Empty;
OAuthWXConfigInfo config = ConfigService <OAuthWXConfigInfo> .GetConfig(string.Concat(WXLoginPlugin.WXWorkDirectory, "\\Config\\OAuthWXConfig.config"));
if ((queryString["code"] == null ? false : queryString["state"] != null))
{
empty = queryString["code"];
item = queryString["state"];
if (string.IsNullOrEmpty(config.AppSecret))
{
throw new MissingFieldException("未设置AppSecret！");
}
UserInfo userInfo = WeiXinApi.GetUserInfo(empty, config.AppId, config.AppSecret);
oAuthUserInfo.OpenId = (string.IsNullOrWhiteSpace(userInfo.unionid) ? userInfo.openid : userInfo.unionid);
oAuthUserInfo.NickName = userInfo.nickname;
oAuthUserInfo.IsMale = new bool?((userInfo.sex == 0 ? false : true));
}
return(oAuthUserInfo);
}
public void UpdateUserForWx(string openid, OAuthUserInfo userInfo)
{
using (var db = new PortalDb())
{
var user = db.Users.FirstOrDefault(n => n.OpenId == openid);
if (user == null)
{
return;
}
user.ImgUrl = userInfo.headimgurl;
user.Gender = userInfo.sex.ToString();
user.Province = userInfo.province;
user.Country = userInfo.country;
user.City = userInfo.city;
user.AuthType = AuthType.WeiXin;
user.OpenId = userInfo.openid;
user.Active = true;
user.ModifyTime = DateTime.Now;
user.LastLoginDateUtc = DateTime.Now;
db.SaveChanges();
}
}
public OAuthUserInfo GetWeChatUserInfo(ISettingService _settingService, ICacheManager cacheManager, string openId)
{
var appId = _settingService.GetSettingByKey <string>(WeChatSettingNames.AppId);
var appSecret = _settingService.GetSettingByKey <string>(WeChatSettingNames.AppSecret);
try
{
var Logger = Abp.Dependency.IocManager.Instance.Resolve <ILogger>();
Logger.Debug("获取用户信息");
var token = GetAccessToken(cacheManager, appId, appSecret);
OAuthUserInfo userInfo = HttpUtility.Get <OAuthUserInfo>(string.Format("https://api.weixin.qq.com/cgi-bin/user/info?access_token={0}&openid={1}&lang=zh_CN", token.access_token, openId), Logger);
Logger.Debug(token.access_token + "|||" + userInfo.nickname + "|||" + userInfo.openid);
return(userInfo);
}
catch
{
}
return(null);
}
public Account CreateAccountByUserInfo(OAuthUserInfo userInfo, int parentAccountId = 0)
{
var time = DateTime.Now;
Account account = null;
string userName = GetNewUserName();
account = CreateAccount(userName, "", "", "", userInfo.openid);
account.Sex = (byte)userInfo.sex;
account.HeadImgUrl = userInfo.headimgurl;
account.NickName = userInfo.nickname;
//account.Country = userInfo.country;
account.Province = userInfo.province;
account.City = userInfo.city;
var fileName = @"/Upload/Account/headimgurl.{0}.jpg".With(DateTime.Now.Ticks + Guid.NewGuid().ToString("n").Substring(0, 8));
//下载图片
DownLoadPic(userInfo.headimgurl, fileName);
account.PicUrl = fileName;
SaveObject(account);
return(account);
}
public OAuthUserInfo GetUserInfo(NameValueCollection queryString)
{
OAuthWeiboConfig config = WeiboCore.GetConfig();
NetDimension.Weibo.OAuth oAuth = new NetDimension.Weibo.OAuth(config.AppKey, config.AppSecret, Service.ReturnUrl);
Client client = new Client(oAuth);
oAuth.GetAccessTokenByAuthorizationCode(queryString["code"]);
OAuthUserInfo oAuthUserInfo = null;
if (oAuth != null)
{
oAuthUserInfo = new OAuthUserInfo();
oAuthUserInfo.OpenId = client.API.Entity.Account.GetUID();
Entity entity = client.API.Entity.Users.Show(oAuthUserInfo.OpenId, "");
string name = entity.Name;
string str = name;
oAuthUserInfo.RealName = name;
oAuthUserInfo.NickName = str;
oAuthUserInfo.IsMale = new bool?(entity.Gender == "m");
}
return(oAuthUserInfo);
}
/// <summary>
/// 关注用户回写数据库
/// </summary>
/// <param name="userInfo"></param>
/// <returns></returns>
public bool FollowMP(OAuthUserInfo userInfo)
{
//todo 用户取关检测
//检查输入项
string apiUrl = System.Configuration.ConfigurationManager.AppSettings["ApiUrl"];
string url = string.Format("{0}/WxUserInfo/Create", apiUrl);
RequestHelper.Create(url);
RequestHelper.WebRequest.ContentType = "application/json;charset=UTF-8";
RequestHelper.WebRequest.Headers.Add("Accept-Encoding: gzip, deflate");
RequestHelper.WebRequest.AutomaticDecompression = System.Net.DecompressionMethods.Deflate;
var tmp = new Sys.Models.WxUserInfo()
{
City = userInfo.city,
Country = userInfo.country,
HeadImgUrl = userInfo.headimgurl,
LastLoginTime = DateTime.Now,
NickName = userInfo.nickname,
OpenId = userInfo.openid,
Province = userInfo.province,
Sex = userInfo.sex == 1,
State = 1,
};
string jsonStr = JsonHelper.ToJsonStringByNewtonsoft(tmp);
string result = RequestHelper.PostString(jsonStr);
JObject jo = JObject.Parse(result);
if (Convert.ToBoolean(jo["Error"].ToString()))
{
throw new Comm.YYException.YYException(jo["Msg"].ToString());
}
return(true);
}
public OAuthUserInfo GetUserInfo(NameValueCollection queryString)
{
bool flag;
QOpenClient qOpenClient = null;
string item = queryString["code"];
string str = queryString["state"];
OAuthQQConfig config = QQCore.GetConfig();
string str1 = string.Concat(config.AuthorizeURL, "?grant_type=authorization_code&client_id={0}&state={2}&client_secret={3}&code={4}&redirect_uri={1}");
object[] appId = new object[] { config.AppId, Service.ReturnUrl, str, config.AppKey, item };
string.Format(str1, appId);
QQConnectConfig.SetCallBackUrl(Service.ReturnUrl);
qOpenClient = new QOpenClient(config.AuthorizeURL, config.AppId, config.AppKey, item, str);
OAuthUserInfo oAuthUserInfo = null;
if (qOpenClient != null)
{
oAuthUserInfo = new OAuthUserInfo();
User currentUser = qOpenClient.GetCurrentUser();
oAuthUserInfo.NickName = currentUser.Nickname;
oAuthUserInfo.RealName = currentUser.Nickname;
if (string.IsNullOrWhiteSpace(currentUser.Gender))
{
flag = true;
}
else
{
flag = (currentUser.Gender == "男" ? false : !(currentUser.Gender == "女"));
}
if (!flag)
{
oAuthUserInfo.IsMale = new bool?((currentUser.Gender == "男" ? true : false));
}
oAuthUserInfo.OpenId = qOpenClient.OAuthToken.OpenId;
}
return(oAuthUserInfo);
}
public object Do_GetUser(object param)
{
//try
//{
UserParam userParam = JsonConvert.DeserializeObject <UserParam>(param.ToString());
if (userParam == null)
{
Console.WriteLine("InvalidParam");
Console.WriteLine(param.ToString());
throw new ApiException(CodeMessage.InvalidParam, "InvalidParam");
}
var appBag = AppContainer.GetAppBag(userParam.token);
OAuthUserInfo userInfo = JsonConvert.DeserializeObject <OAuthUserInfo>(appBag.AppObj.ToString());
if (appBag != null)
{
return(userInfo);
}
else
{
Console.WriteLine("InvalidToken");
Console.WriteLine(userParam.token);
throw new ApiException(CodeMessage.InvalidToken, "InvalidToken");
}
//}
//catch(Exception ex)
//{
// Console.WriteLine(ex.Message);
// Console.WriteLine(ex.StackTrace);
// Console.WriteLine(ex.InnerException.Message);
// Console.WriteLine(ex.InnerException.StackTrace);
// throw new ApiException(CodeMessage.InnerError, "InnerError");
//}
}
public void UpdateAccountByUserInfo(OAuthUserInfo userInfo, Account account)
{
LogUtility.Account.InfoFormat("用户【{0}】微信信息更新：{0},{1},{2}", userInfo.openid, userInfo.headimgurl, userInfo.nickname);
//删除图片
if (!account.PicUrl.IsNullOrEmpty())
{
File.Delete(Server.GetMapPath("~" + account.PicUrl));
}
//account.WeixinOpenId = userInfo.openid;
account.Sex = (byte)userInfo.sex;
account.HeadImgUrl = userInfo.headimgurl;
account.NickName = userInfo.nickname;
account.Province = userInfo.province;
account.City = userInfo.city;
var fileName = @"/Upload/Account/headimgurl.{0}.jpg".With(DateTime.Now.Ticks + Guid.NewGuid().ToString("n").Substring(0, 8));
//下载图片
DownLoadPic(userInfo.headimgurl, fileName);
account.PicUrl = fileName;
this.SaveObject(account);
}
private string RegisterUser(string openId, OAuthUserInfo userInfo)
{
ELoginStatus status = ELoginStatus.Success;
return(RegisterUser(openId, userInfo, out status));
}
/// <summary>
/// 静默模式
/// </summary>
/// <param name="code"></param>
/// <param name="state"></param>
/// <returns></returns>
public ActionResult BaseCallback(string code, string state)
{
if (string.IsNullOrEmpty(code))
{
return(Content("您拒绝了授权！"));
}
if (state != STATE)
{
//这里的state其实是会暴露给客户端的，验证能力很弱，这里只是演示一下
//实际上可以存任何想传递的数据，比如用户ID，并且需要结合例如下面的Session["OAuthAccessToken"]进行验证
return(Content("验证失败！请从正规途径进入！"));
}
//通过，用code换取access_token
var result = OAuthApi.GetAccessToken(appId, secret, code);
if (result.errcode != ReturnCode.请求成功)
{
return(Content("错误：" + result.errmsg));
}
//下面2个数据也可以自己封装成一个类，储存在数据库中（建议结合缓存）
//如果可以确保安全，可以将access_token存入用户的cookie中，每一个人的access_token是不一样的
Session["OAuthAccessTokenStartTime"] = DateTime.Now;
Session["OAuthAccessToken"] = result;
//判断用户是否存存
string userId = null;
try
{
userId = GetUserIdByOpenId(result.openid);
}
catch (Exception ex)
{
}
if (userId == null)
{
//因为这里还不确定用户是否关注本微信，所以只能试探性地获取一下
OAuthUserInfo userInfo = null;
try
{
if (ReqietTryGetUser)
{
//已关注，可以得到详细信息
userInfo = OAuthApi.GetUserInfo(result.access_token, result.openid);
}
if (string.IsNullOrEmpty(Request["referer"]))
{
ViewData["ByBase"] = true;
return(View("UserInfoCallback", userInfo));
}
else
{
}
}
catch (ErrorJsonResultException ex)
{
//未关注，只能授权，无法得到详细信息
//这里的 ex.JsonResult 可能为："{\"errcode\":40003,\"errmsg\":\"invalid openid\"}"
//return Content("用户已授权，授权Token：" + result);
}
if (userInfo != null && result.openid == userInfo.openid && userInfo.nickname != null)
{
userId = RegisterUser(result.openid, userInfo);
}
}
string referer = Request["referer"] ?? "/";
if (userId == null)
{
//授权登陆
string toUrl = string.Format(baseUrl + "UserInfoCallback?referer={0}", HttpUtility.UrlEncode(referer));
string url = OAuthApi.GetAuthorizeUrl(appId, toUrl, STATE, OAuthScope.snsapi_userinfo);
return(Redirect(url));
}
else
{
if (!LoginByUserId(userId))
{
return(Content("登陆失败 userId：" + userId));
}
//登陆用户
return(RedirectToUrl(referer));
}
}
