public async Task <UserRepositoryModel> GetApplyFriendsAsync(EaUser user, int s, int t)
{
var uss = NonTrackingAsyncEnum.Where(u => u.IsEnable && u.Status == Friend.Applying && u.Target == user.Id);
var count = await uss.Count();
var datas = await uss.Skip(s).Take(t).ToArray();
var ucol = datas.Select(d => d.Target);
var usdatas = new RelFriend[datas.Count()];
var users = await _userManager.Users.AsNoTracking().ToAsyncEnumerable()
.Where(u => ucol.Contains(u.Id))
.ToDictionary(u => u.Id, u => u.UserName);
for (int i = 0; i < datas.Count(); i++)
{
var odata = datas[i];
usdatas[i] = new RelFriend()
{
Id = odata.Id,
CreateTime = odata.CreateTime,
Target = odata.Target,
Creator = odata.Creator,
Status = odata.Status,
TargetName = users[odata.Target]
};
}
var upm = new UserRepositoryModel(count, s, t, usdatas);
return(upm);
}
public async Task <IActionResult> Register([FromForm] ApiRegisterModel model)
{
if (model == null || model.GetType().GetProperties().Any(p => string.IsNullOrEmpty(p.GetValue(model).ToString())))
{
return(BadRequest("模型验证失败"));
}
if (_dbContext.Users.Where(u => u.Email == model.Email).Any())
{
return(BadRequest("邮箱已注册"));
}
if (_dbContext.Users.Where(u => u.UserName == model.UserName).Any())
{
return(BadRequest("用户名已注册"));
}
var user = new EaUser {
UserName = model.UserName, Email = model.Email, CreateTime = DateTime.Now, Type = "default"
};
var result = await _userManager.CreateAsync(user, model.Pwd);
if (result.Succeeded)
{
//_logger.LogInformation("User created a new account with password.");
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
#warning 这里没改
//var callbackUrl = Url.EmailConfirmationLink(user.Id, code, Request.Scheme);
var res = await _emailSender.SendEmailConfirmationAsync(model.Email, "");
return(Ok());
}
return(BadRequest(result.Errors));
}
public async Task <MsgDetailRepositoryModel> GetMsgDetailsAsync(EaUser user, uint mid, int s, int t, bool isdes = false)
{
var msgs = await NonTrackingAsyncEnum.SingleOrDefault(m => m.IsEnable && m.Id == mid && m.Creator == user.Id || m.Target == user.Id);
if (msgs == null)
{
return(new MsgDetailRepositoryModel(false));
}
var mds = _msgDetailRepository.Where(m => m.MsgId == msgs.Id && m.IsEnable);
if (isdes)
{
mds = mds.OrderBy(m => m.Id);
}
else
{
mds = mds.OrderByDescending(m => m.Id);
}
var count = await mds.Count();
var datas = await mds.Skip(s).Take(t).ToArray();
await _msgDetailRepository.AutoFillAsync(datas);
var mdpm = new MsgDetailRepositoryModel(count, s, t, datas);
return(mdpm);
}
public async Task <bool> SendCommentAsync(EaUser user, uint cid, string cstring)
{
var content = await DbSet.ToAsyncEnumerable().SingleOrDefault(c => c.Id == cid && c.IsEnable);
Console.WriteLine($"cid={cid} hascontent={content!=null}");
if (content == null)
{
Console.WriteLine("content null");
return(false);
}
if (string.IsNullOrEmpty(cstring))
{
return(false);
}
_commentRepository.DbSet.Add(new Comment()
{
ContentId = content.Id,
CreateTime = DateTime.Now,
HtmlContent = cstring,
EaUserId = user.Id
});
await DbContext.SaveChangesAsync();
return(true);
}
public async Task <IActionResult> ExternalLoginConfirmation(ExternalLoginViewModel model, string returnUrl = null)
{
if (ModelState.IsValid)
{
// Get the information about the user from the external login provider
var info = await _signInManager.GetExternalLoginInfoAsync();
if (info == null)
{
throw new ApplicationException("Error loading external login information during confirmation.");
}
var user = new EaUser {
UserName = model.Email, Email = model.Email
};
var result = await _userManager.CreateAsync(user);
if (result.Succeeded)
{
result = await _userManager.AddLoginAsync(user, info);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, isPersistent : false);
_logger.LogInformation("User created an account using {Name} provider.", info.LoginProvider);
return(RedirectToLocal(returnUrl));
}
}
AddErrors(result);
}
ViewData["ReturnUrl"] = returnUrl;
return(View(nameof(ExternalLogin), model));
}
public async Task <IActionResult> Register(RegisterViewModel model, string returnUrl = null)
{
ViewData["ReturnUrl"] = returnUrl;
if (ModelState.IsValid)
{
var email = model.Email.ToLower();
if (_dbContext.Users.Any(u => u.Email.ToLower() == email))
{
ModelState.AddModelError(string.Empty, "该邮箱已注册!");
return(View(model));
}
var user = new EaUser {
UserName = model.Name, Email = model.Email, CreateTime = DateTime.Now, Type = "default"
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
//_logger.LogInformation("User created a new account with password.");
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.EmailConfirmationLink(user.Id, code, Request.Scheme);
var res = await _emailSender.SendEmailConfirmationAsync(model.Email, callbackUrl);
//await _signInManager.SignInAsync(user, isPersistent: true);
//_logger.LogInformation("User created a new account with password.");
return(RedirectToLocal(returnUrl));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <MsgRepositoryModel> GetMsgAsync(EaUser user, int s, int t)
{
var msgs = NonTrackingAsyncEnum.Where(m => m.Creator == user.Id || m.Target == user.Id && m.IsEnable);
var count = await msgs.Count();
var datas = await msgs.Skip(s).Take(t).ToArray();
var mpm = new MsgRepositoryModel(count, s, t, datas);
return(mpm);
}
public async Task <FriendRepositoryModel> GetFriendsAsync(EaUser user, int skip, int take)
{
var fs = NonTrackingAsyncEnum.Where(f => f.Status == Friend.Applied && f.IsEnable && f.Creator == user.Id || f.Target == user.Id);
var count = await fs.Count();
var datas = await fs.Skip(skip).Take(take).ToArray();
var fpm = new FriendRepositoryModel(count, skip, take, datas);
return(fpm);
}
public async Task <ContentRepositoryModel> GetUserContentsAsync(EaUser user, int s, int t)
{
var us = NonTrackingAsyncEnum.Where(c => c.EaUserId == user.Id && c.IsEnable);
var count = await us.Count();
var datas = await us.Skip(s).Take(t).ToArray();
var crm = new ContentRepositoryModel(count, s, t, datas);
return(crm);
}
public async Task <bool> UnLikeContentAsync(EaUser user, uint cid)
{
var like = await _likeRepository.SingleOrDefault(l => l.ContentId == cid && l.EaUserId == user.Id);
if (like != null)
{
like.IsEnable = false;
_likeRepository.DbSet.Update(like);
DbContext.SaveChanges();
}
return(false);
}
public async Task <string> SendContentAsync(EaUser user, IFormCollection files)
{
var content = files["Content"].FirstOrDefault();
var title = files["Title"].FirstOrDefault();
var label = files["Label"].FirstOrDefault();
var res = await SendContentAsync(user.Id, content, title, label, -1, files.Files.Select(f => new FormFileModel(f)));
if (res != null)
{
return(res);
}
return(null);
}
public async Task <bool> DeleteFirendAsync(EaUser user, string fuid)
{
var fuser = await DbSet.ToAsyncEnumerable().SingleOrDefault(f => f.IsEnable && f.Creator == user.Id && f.Target == fuid && f.Status == Friend.Applied);
if (fuser == null)
{
return(false);
}
fuser.IsEnable = false;
DbSet.Update(fuser);
var res = DbContext.SaveChanges();
return(res > 0);
}
public async Task <bool> DeleteMsgAsync(EaUser user, uint mid)
{
var msg = await NonTrackingAsyncEnum.SingleOrDefault(m => m.IsEnable && m.Id == mid && m.Creator == user.Id);
if (msg == null)
{
return(false);
}
msg.IsEnable = false;
DbSet.Update(msg);
var res = DbContext.SaveChanges();
return(res > 0);
}
private async Task LoadSharedKeyAndQrCodeUriAsync(EaUser user, EnableAuthenticatorViewModel model)
{
var unformattedKey = await _userManager.GetAuthenticatorKeyAsync(user);
if (string.IsNullOrEmpty(unformattedKey))
{
await _userManager.ResetAuthenticatorKeyAsync(user);
unformattedKey = await _userManager.GetAuthenticatorKeyAsync(user);
}
model.SharedKey = FormatKey(unformattedKey);
model.AuthenticatorUri = GenerateQrCodeUri(user.Email, unformattedKey);
}
public async Task <ShopItemRepositoryModel> GetUserItemsAsync(EaUser user, int s, int t, bool searchUnEnable = false)
{
var sis = _buyRepository.Where(b => (!searchUnEnable && b.IsEnable) && b.EaUserId == user.Id)
.Skip(s)
.Take(t);
var count = await sis.Count();
var sisid = await sis.Select(d => d.ShopItemId).ToArray();//已购买的商品id
var datas = await _shopItemRepository.Where(si => sisid.Contains(si.Id)).ToArray();
var model = new ShopItemRepositoryModel(count, s, t, datas);
return(model);
}
public async Task <bool> AcceptFriendApplyAsync(EaUser user, uint fid)
{
var friend = await DbSet.ToAsyncEnumerable().SingleOrDefault(f => f.Id == fid && f.IsEnable);
Console.WriteLine($"accept f.creator={friend.Creator} f.target={friend.Target} locid={user.Id} fid={fid}");
if (friend == null || friend.Target != user.Id)
{
return(false);
}
friend.Status = Friend.Applied;
DbSet.Update(friend);
var res = await DbContext.SaveChangesAsync();
return(res > 0);
}
public async Task <IActionResult> GetUserById(string id)
{
var user = await _userManager.FindByIdAsync(id);
EaUser u = new EaUser();
if (user != null)
{
u.Id = user.Id;
u.UserName = user.UserName;
u.Type = user.Type;
u.Email = user.Email;
}
return(Json(u));
}
public async Task <ContentRepositoryModel> GetLikeContentAsync(EaUser user, int t, int s)
{
var cs = _likeRepository.Where(c => c.EaUserId == user.Id && c.IsEnable)
.Skip(s)
.Take(t)
.Select(c => c.ContentId); //喜欢的内容页
var count = await cs.Count();
var lcs = await cs.ToList();
var datas = await NonTrackingAsyncEnum.Where(c => lcs.Contains(c.Id) && c.IsEnable).ToArray();
var cpm = new ContentRepositoryModel(count, s, t, datas);
return(cpm);
}
public async Task <bool> LikeContentAsync(EaUser user, uint cid)
{
var islike = await IsLikeAsync(user.Id, cid);
if (!islike)
{
_likeRepository.DbSet.Add(new Like()
{
EaUserId = user.Id,
ContentId = cid
});
var res = DbContext.SaveChanges();
return(res > 0);
}
return(false);
}
public async Task <bool> SendMsgAsync(EaUser user, MsgSendModel model)
{
var msg = await NonTrackingAsyncEnum.SingleOrDefault(s => s.Id == model.Mid);
if (msg == null)
{
return(false);
}
_msgDetailRepository.DbSet.Add(new MsgDetail()
{
Content = model.Text,
MsgId = model.Mid,
Cmds = model.Cmd
});
var res = DbContext.SaveChanges();
return(res > 0);
}
public async Task <bool> QuireNeedUpdateAsync(EaUser user, uint mid, uint lmid)
{
var msg = await NonTrackingAsyncEnum.SingleOrDefault(s => s.Id == mid);
if (msg == null)
{
return(false);
}
var rlmid = await _msgDetailRepository.Where(md => md.MsgId == msg.Id)
.OrderBy(md => md.Id)
.LastOrDefault();
if (rlmid == null)//没有消息具体
{
return(true);
}
return(rlmid.Id > lmid);
}
public async Task <bool> CreatMsgAsync(EaUser user, string fid)
{
if (user.Id == fid)
{
return(false);
}
var hasFriend = await _friendRepository.NonTrackingAsyncEnum.Any(f => f.IsEnable && f.Status == Friend.Applied && f.Creator == user.Id && f.Target == fid);
if (!hasFriend)
{
return(false);
}
DbSet.Add(new Msg()
{
Creator = user.Id,
Target = fid
});
var res = await DbContext.SaveChangesAsync();
return(res > 0);
}
public async Task <bool> BuyAsync(EaUser user, uint itemId)
{
var ic = await _shopItemRepository.DbSet.SingleOrDefaultAsync(i => i.Id == itemId);
if (ic == null)
{
return(false);
}
if (user.Money - ic.Price <= 0)
{
return(false);
}
user.Money -= ic.Price;
await _userManager.UpdateAsync(user);
DbSet.Add(new Buy()//添加记录
{
ShopItemId = itemId,
EaUserId = user.Id
});
return(true);
}
public async Task <bool> ApplyFriendAsync(EaUser user, string fid)
{
var fuser = await _userManager.FindByIdAsync(fid);
if (fuser == null)
{
return(false);//失败
}
var has = await AsyncEnumerable.Any(f => f.IsEnable && f.Target == user.Id || f.Creator == user.Id);
if (fuser.Id == user.Id || has)
{
return(false);
}
DbSet.Add(new Friend()
{
Creator = user.Id,
Target = fid
});
var res = await DbContext.SaveChangesAsync();
return(res > 0);
}
public async Task <bool> IsLikeContentAsync(EaUser user, uint cid)
{
var islike = await IsLikeAsync(user.Id, cid);
return(islike);
}
public async Task <bool> BuyAsync(EaUser user, uint iid)
{
var buyres = await _buyRepository.BuyAsync(user, iid);
return(buyres);
}
public async Task <bool> DeleteCommentAsync(EaUser user, uint cid)
{
var res = await _commentRepository.DeleteCommentAsync(user.Id, cid);
return(res);
}
public async Task <bool> DeleteContentAsync(EaUser user, uint cid)
{
var res = await _DeleteContentAsync(user.Id, cid);
return(res);
}
