public ActionResult Register(RegisterModel model)
{
if (ModelState.IsValid)
{
// Attempt to register the user
var user = new MembershipDto();
object userKey;
MembershipCreateStatus createStatus;
user.CreateUser(model.UserName, model.Email, model.Password, out userKey, out createStatus);
if (createStatus.Equals(MembershipCreateStatus.Success))
{
// 注册成功后，直接将表单的用户名，存入cookie
FormsAuthentication.SetAuthCookie(model.UserName, false);
UserDto.SetSession(userKey);
// 如果开启微信授权则跳转微信OpenUrl, 跳转首页
if (BrowserInfo.IsWeChatClient() && ConfigGlobal_Arsenal.WeChatActive)
{
TempData["DataUrl"] = $"data-url=/Account/WeChatLogin/?scope={ScopeType.snsapi_userinfo}";
return(RedirectToAction("WeChatLogin", "Account", new { scope = ScopeType.snsapi_userinfo }));
}
TempData["DataUrl"] = "data-url=/";
return(RedirectToAction("Index", "Home"));
}
ModelState.AddModelError("Warn", ErrorCodeToString(createStatus));
}
// If we got this far, something failed, redisplay form
return(View(model));
}
// 切换用户账号
// GET: /Account/AvatarLogin
public ActionResult AvatarLogin(Guid userGuid)
{
var user = UserDto.GetSession();
var newUser = UserDto.Single(userGuid);
if (user.WeChatOpenID != null && newUser.WeChatOpenID != null &&
user.WeChatOpenID == newUser.WeChatOpenID)
{
#region 注销当前用户
user.LastActivityDate = DateTime.Now;
_repo.Update(user);
FormsAuthentication.SignOut();
Session.Abandon();
#endregion
#region 登录新用户
var mem = MembershipDto.Single(userGuid);
FormsAuthentication.SetAuthCookie(mem.UserName, createPersistentCookie: true);
UserDto.SetSession(mem.SignIn(), isAnonymous: true);
#endregion
}
TempData["DataUrl"] = "data-url=/";
return(RedirectToAction("Index", "Home"));
}
private static MembershipDto MemberToDo(Membership person)
{
var ret = new MembershipDto
{
PersonID = person.PersonID,
Person = person.Person,
Stable = person.Stable,
StableID = person.StableID,
BillsID = new List <int>(),
RegistrationsID = new List <int>()
};
if (person.Bills != null)
{
foreach (var bill in person.Bills)
{
ret.BillsID.Add(bill.ID);
}
}
if (person.Registrations != null)
{
foreach (var register in person.Registrations)
{
ret.RegistrationsID.Add(register.PersonID);
}
}
return(ret);
}
public ActionResult UserProfile(UserProfileDto model)
{
if (ModelState.IsValid)
{
try
{
var membership = MembershipDto.Single(User.Identity.Name);
var user = UserDto.GetSession();
if (membership != null && user != null)
{
user.MemberName = model.RealName;
membership.Email = model.Email;
membership.Mobile = model.Mobile;
_repo.Update(user);
_repo.Update(membership);
TempData["DataUrl"] = "data-url=/Account";
return(RedirectToAction("Index", "Account"));
}
ModelState.AddModelError("Warn", "当前用户不存在");
}
catch (Exception ex)
{
ModelState.AddModelError("Warn", ex.Message);
}
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <IActionResult> AddMembership([FromBody] MembershipDto membershipDto)
{
var command = new AddMembershipCommand(membershipDto);
var result = await _mediator.Send(command);
return(Ok(result));
}
public async Task <IActionResult> UpdateMembership([FromBody] MembershipDto membershipDto)
{
var updateMembership = _membership.UpdateAsync(membershipDto);
await _membershipRepository.UpdateAsync(updateMembership);
return(Ok(updateMembership));
}
public async Task <IActionResult> CreateMembership([FromBody] MembershipDto membershipDto)
{
var createMembership = _membership.CreateAsync(membershipDto);
await _membershipRepository.AddAsync(createMembership);
return(Ok(createMembership));
}
public IHttpActionResult GetMembership(string userId, long teamId)
{
var membership = memSvc.GetMembership(teamId, userId);
if (membership == null)
{
return(NotFound());
}
return(Ok(MembershipDto.FromMembership(membership)));
}
// POST tables/Member
public async Task <IHttpActionResult> PostMembership(MembershipDto item)
{
Membership current;
var exists = _context.Memberships.FirstOrDefault(m => m.AthleteId == item.AthleteId && m.LeagueId == item.LeagueId && m.AbandonDate == null);
if (exists != null)
{
//Athlete is already a member of this league
current = exists;
}
else
{
var prior = _context.Memberships.Where(m => m.LeagueId == item.LeagueId && m.AbandonDate == null)
.OrderByDescending(m => m.CurrentRank).FirstOrDefault();
if (prior != null)
{
item.CurrentRank = prior.CurrentRank + 1;
}
current = await InsertAsync(item.ToMembership());
if (WebApiConfig.IsDemoMode)
{
//Keep the lists to a reasonable amount
var list = _context.Memberships.Where(m => m.LeagueId == item.LeagueId && m.AbandonDate == null).ToList();
if (list.Count > WebApiConfig.MaxLeagueMembershipCount)
{
var diff = list.Count - WebApiConfig.MaxLeagueMembershipCount;
var oldest = list.OrderBy(m => m.CreatedAt).Take(diff);
foreach (var m in oldest)
{
await DeleteMembership(m.Id);
}
}
}
}
try
{
var leagueName = _context.Leagues.Where(l => l.Id == item.LeagueId).Select(l => l.Name).ToList().First();
var athlete = _context.Athletes.Where(a => a.Id == item.AthleteId).First();
var message = "{0} joined the {1} league".Fmt(athlete.Alias, leagueName);
await _notificationController.NotifyByTag(message, item.LeagueId);
}
catch (Exception e)
{
//TODO log to Insights
Console.WriteLine(e);
}
return(CreatedAtRoute("Tables", new { id = current.Id }, current));
}
public IHttpActionResult GetMembership(long id)
{
Membership membership = memSvc.GetMembership(id);
if (membership == null)
{
return(NotFound());
}
return(Ok(MembershipDto.FromMembership(membership)));
}
public static bool EqualValues(this MembershipDto membershipDto, Membership membership)
{
bool equal = membershipDto.DateCreated == membership.DateCreated &&
membershipDto.DateModified == membership.DateModified &&
membershipDto.ID == membership.ID &&
membershipDto.MembershipStatus == membership.MembershipStatus &&
membershipDto.TeamID == membership.TeamID &&
membershipDto.UserID == membership.UserID;
return(equal);
}
public IHttpActionResult PostMembership(Membership membership)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
memSvc.CreateMembership(membership);
uow.Save();
return(CreatedAtRoute("DefaultApi", new { id = membership.ID }, MembershipDto.FromMembership(membership)));
}
// 用户信息
// GET: /Account/UserProfile
public ActionResult UserProfile()
{
var model = new UserProfileDto();
var membership = MembershipDto.Single(User.Identity.Name);
var user = UserDto.GetSession();
model.RealName = user.MemberName;
model.Mobile = membership.Mobile;
model.Email = membership.Email;
return(View(model));
}
public async Task UpdateAsync(Guid currentMembershipId, MembershipDto newMembership)
{
var membership = await _domainContext.Memberships.FirstOrDefaultAsync(e => e.Id == currentMembershipId);
if (membership != null)
{
membership.NameOfCompany = newMembership.NameOfCompany;
membership.StatusInTheOrganization = newMembership.StatusInTheOrganization;
membership.DateOfEntry = newMembership.DateOfEntry;
membership.SiteOfTheOrganization = newMembership.SiteOfTheOrganization;
membership.SiteOfTheJournal = newMembership.SiteOfTheJournal;
membership.EmployeeId = newMembership.EmployeeId;
}
}
public static Membership ToMembership(this MembershipDto dto)
{
return(new Membership
{
Id = dto.Id,
UpdatedAt = dto.UpdatedAt,
CurrentRating = dto.CurrentRating,
NumberOfGamesPlayed = dto.NumberOfGamesPlayed,
AthleteId = dto.AthleteId,
IsAdmin = dto.IsAdmin,
LastRankChange = dto.LastRankChange,
LeagueId = dto.LeagueId,
AbandonDate = dto.AbandonDate,
});
}
public async Task CreateMembership(MembershipDto membershipDto)
{
var user = await this.dbContext.Users
.FirstOrDefaultAsync(userId => userId.Id == membershipDto.UserId);
if (user == null)
{
throw new UserExeption("Does not exist");
}
user.CreatedOn = DateTime.Now;
user.Expired = DateTime.Now.AddMonths(membershipDto.Months);
await this.dbContext.SaveChangesAsync();
}
public static Membership ToMembership(this MembershipDto dto)
{
return(new Membership
{
Id = dto.Id,
UpdatedAt = dto.UpdatedAt,
CurrentRank = dto.CurrentRank,
AthleteId = dto.AthleteId,
IsAdmin = dto.IsAdmin,
CreatedAt = dto.DateCreated,
LastRankChange = dto.LastRankChange,
LeagueId = dto.LeagueId,
AbandonDate = dto.AbandonDate,
});
}
public static Membership ToModel(this MembershipDto dto)
{
return(new Membership
{
Id = dto.Id,
Name = dto.Name,
HashAlgorithm = dto.HashAlgorithm,
DefaultEncoding = dto.DefaultEncoding,
DefaultLanguage = dto.DefaultLanguage,
ExpiresIn = dto.ExpiresIn,
SecretKey = dto.SecretKey,
RefreshTokenExpiresIn = dto.RefreshTokenExpiresIn,
MailSettings = dto.MailSettings?.ToModel(),
Sys = dto.Sys?.ToModel()
});
}
public async Task <Membership> CreateOrUpdate(Guid?membershipId, MembershipDto createdMembershipData)
{
if (membershipId == null)
{
var membership = _membershipRepository.Add(createdMembershipData);
await _domainContext.SaveChangesAsync();
return(await _membershipRepository.GetAsync(membership.Id));
}
await _membershipRepository.UpdateAsync(membershipId.Value, createdMembershipData);
await _domainContext.SaveChangesAsync();
return(await _membershipRepository.GetAsync(membershipId.Value));
}
public Membership Add(MembershipDto addedMembership)
{
var membership = new Membership()
{
NameOfCompany = addedMembership.NameOfCompany,
StatusInTheOrganization = addedMembership.StatusInTheOrganization,
DateOfEntry = addedMembership.DateOfEntry,
MembershipType = addedMembership.MembershipType,
EmployeeId = addedMembership.EmployeeId,
SiteOfTheOrganization = addedMembership.SiteOfTheOrganization,
SiteOfTheJournal = addedMembership.SiteOfTheJournal
};
_domainContext.Memberships.Add(membership);
return(membership);
}
public Membership CreateAsync(MembershipDto membershipDto)
{
var membership = new Membership();
membership.Name = membershipDto.Name;
membership.Category = membershipDto.Category;
membership.Period = membershipDto.Period;
membership.Limit = membershipDto.Limit;
membership.LimitType = membershipDto.LimitType;
membership.Amount = membershipDto.Amount;
membership.SignupFee = membershipDto.SignupFee;
membership.Description = membershipDto.Description;
membership.Image = membershipDto.Image;
membership.CreatedDate = DateTime.Now;
membership.UpdatedDate = DateTime.Now;
membership.Active = true;
return(membership);
}
public async Task <IActionResult> AddMembers([FromBody] MembershipDto membershipDto)
{
if (membershipDto.InitiativeId == Guid.Empty)
{
logger.LogError("Initiative ID not valid");
return(BadRequest("Initiative ID not valid"));
}
try
{
var result = await _membershipService.AddMembership(membershipDto);
return(Ok(result));
}catch (Exception ex)
{
logger.LogError(ex, ex.Message);
return(BadRequest($"Something went wrong, {ex.Message}"));
}
}
public async Task <IActionResult> Membership(MembershipViewModel vm)
{
try
{
var membershipDto = new MembershipDto
{
UserId = User.FindFirstValue(ClaimTypes.NameIdentifier),
Months = vm.Months
};
await this.service.CreateMembership(membershipDto);
}
catch (UserExeption ex)
{
return(View("Message", new MessageViewModel {
Message = ex.Message
}));
}
return(RedirectToAction("Index", "Home"));
}
public async Task <IActionResult> CreateMember(MembershipDto memberDto)
{
if (memberDto.PersonID == null || memberDto.StableID == null)
{
return(BadRequest());
}
var person = new Membership
{
Person = memberDto.Person,
Stable = memberDto.Stable,
StableID = (int)memberDto.StableID,
};
await _context.Memberships.AddAsync(person);
await _context.SaveChangesAsync();
return(CreatedAtAction(nameof(GetMember), new { id = person.PersonID }, person));
}
public ActionResult ChangePassword(ChangePasswordModel model)
{
if (ModelState.IsValid)
{
try
{
var membership = MembershipDto.Single(User.Identity.Name);
if (membership != null)
{
// ChangePassword will throw an exception rather
// than return false in certain failure scenarios.
if (MembershipDto.ChangePassword(membership, model.OldPassword, model.NewPassword))
{
TempData["DataUrl"] = "data-url=/Account/ChangePasswordSuccess";
return(RedirectToAction("ChangePasswordSuccess", "Account"));
}
}
else
{
//changePasswordSucceeded = false;
ModelState.AddModelError("Warn", "当前用户不存在");
}
}
catch (Exception ex)
{
//changePasswordSucceeded = false;
ModelState.AddModelError("Warn", ex.Message);
}
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <bool> AddMembership(MembershipDto membershipDto)
{
try
{
foreach (var member in membershipDto.Members)
{
var isMember = await baseContext.Memberships
.Where(x => x.InitiativeByYearId == membershipDto.InitiativeId)
.Where(x => x.UserId == member).FirstOrDefaultAsync();
if (isMember == null)
{
Membership membership = new Membership
{
Id = Guid.NewGuid(),
OverallRating = 0,
Role = "Member",
UserId = member,
InitiativeByYearId = membershipDto.InitiativeId,
CreatedBy = "Super Admin",
CreatedDate = DateTime.UtcNow
};
baseContext.Add(membership);
await SaveChanges();
}
}
return(true);
}
catch (Exception ex)
{
logger.LogError(ex, ex.Message);
throw ex;
}
}
public void Upgrade(MembershipDto membership)
{
Console.WriteLine($"Membership of user {membership.Email} upgraded to : {membership.Type}");
}
public ActionResult Login(LoginModel model, string returnUrl)
{
if (ModelState.IsValid)
{
Membership mem;
int acnUid;
var loginSuccess = false;
if (MembershipDto.ValidateUser(model.UserName, out mem))
{
if (mem.Password.Equals(Encrypt.GetMd5Hash(model.Password)))
{
// Sign in
FormsAuthentication.SetAuthCookie(mem.UserName, model.RememberMe);
UserDto.SetSession(mem.SignIn());
loginSuccess = true;
}
else
{
ModelState.AddModelError("Warn", "用户名或密码不正确");
}
}
else if (MembershipDto.ValidateAcnUser(model.UserName, model.Password, out acnUid))
{
// not in SSO, but in Acn Users
// Sync the user info, register SSO and then log in
if (acnUid > 0)
{
var membership = new MembershipDto();
MembershipCreateStatus createStatus;
membership.CreateAcnUser(acnUid, out createStatus);
if (createStatus.Equals(MembershipCreateStatus.Success))
{
FormsAuthentication.SetAuthCookie(membership.UserName, model.RememberMe);
UserDto.SetSession(membership.SignIn());
loginSuccess = true;
}
else
{
ModelState.AddModelError("Warn", ErrorCodeToString(createStatus));
}
}
else
{
ModelState.AddModelError("Warn", ErrorCodeToString(MembershipCreateStatus.InvalidUserName));
}
}
else
{
ModelState.AddModelError("Warn", "用户名不存在或密码不正确");
}
// 处理登录跳转，如果开启微信授权则跳转微信OpenUrl, 否则跳转返回路径, 最后跳转首页
if (loginSuccess)
{
if (BrowserInfo.IsWeChatClient() && ConfigGlobal_Arsenal.WeChatActive)
{
TempData["DataUrl"] = $"data-url=/Account/WeChatLogin/?scope={ScopeType.snsapi_base}";
return(RedirectToAction("WeChatLogin", "Account", new { scope = ScopeType.snsapi_base }));
}
if (Url.IsLocalUrl(returnUrl))
{
TempData["DataUrl"] = $"data-url={returnUrl}";
return(Redirect(returnUrl));
}
TempData["DataUrl"] = "data-url=/";
return(RedirectToAction("Index", "Home"));
}
}
// If we got this far, something failed, redisplay form
return(View(model));
}
// POST tables/Member
public async Task <IHttpActionResult> PostMembership(MembershipDto item)
{
Membership current = null;
var exists = _context.Memberships.FirstOrDefault(m => m.AthleteId == item.AthleteId && m.LeagueId == item.LeagueId && m.AbandonDate == null);
if (exists != null)
{
//Athlete is already a member of this league
current = exists;
}
else
{
try
{
var membership = item.ToMembership();
current = await InsertAsync(membership);
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
var result = CreatedAtRoute("Tables", new { id = current.Id }, current);
if (Startup.IsDemoMode)
{
var tasks = new List <Task>();
//Keep the lists to a reasonable amount for the public-facing service
lock (_syncObject)
{
var query = _context.Memberships.Where(m => m.LeagueId == item.LeagueId && m.AbandonDate == null);
var list = ConvertMembershipToDto(query).ToList();
if (list.Count > Startup.MaxLeagueMembershipCount)
{
var diff = list.Count - Startup.MaxLeagueMembershipCount;
var oldest = list.OrderBy(m => m.CreatedAt).Take(diff).Select(m => m.Id).ToList();
foreach (var mId in oldest)
{
if (mId == current.Id)
{
continue;
}
tasks.Add(DeleteMembershipInternal(mId));
}
}
}
try
{
await Task.WhenAll(tasks);
}
catch (Exception ex)
{
//TODO log to Insights
Console.WriteLine(ex);
}
}
try
{
var leagueName = _context.Leagues.Where(l => l.Id == item.LeagueId).Select(l => l.Name).ToList().First();
var athlete = _context.Athletes.Where(a => a.Id == item.AthleteId).First();
var message = "{0} joined the {1} league".Fmt(athlete.Alias, leagueName);
await _notificationController.NotifyByTag(message, item.LeagueId);
}
catch (Exception e)
{
//TODO log to Insights
Console.WriteLine(e);
}
return(result);
}
public void Activate(MembershipDto membership)
{
Console.WriteLine($"Membership activated for user {membership.Email}");
}
