public IActionResult Login(LoginUser user)
{
var test = dbContext.Users.ToList();
if (ModelState.IsValid)
{
DashboardUser toLogin = dbContext.Users.FirstOrDefault(u => u.Email == user.EmailAttempt);
if (toLogin == null)
{
ModelState.AddModelError("EmailAttempt", "Invalid Email/Password");
return(View("Index"));
}
PasswordHasher <LoginUser> hasher = new PasswordHasher <LoginUser>();
var result = hasher.VerifyHashedPassword(user, toLogin.Password, user.PasswordAttempt);
if (result == PasswordVerificationResult.Failed)
{
ModelState.AddModelError("EmailAttempt", "Invalid Email/Password");
return(View("Index"));
}
// Log user into session
HttpContext.Session.SetInt32("userId", toLogin.UserId);
HttpContext.Session.SetString("userName", toLogin.FirstName);
return(RedirectToAction("Index", "Dashboard"));
}
return(View("Index"));
}
public IActionResult Login(LogRegModel model)
{
LoginUser user = model.Login;
if (ModelState.IsValid)
{
// is this user's email in the db???
DashboardUser userCheck = dbContext.Users.FirstOrDefault(u => u.Email == user.EmailAttempt);
if (userCheck == null)
{
// we have a problem
ModelState.AddModelError("Login.EmailAttempt", "Invalid Email/Password");
return(View("Index"));
}
else
{
// check for db.password == form.password
PasswordHasher <LoginUser> hasher = new PasswordHasher <LoginUser>();
PasswordVerificationResult result = hasher.VerifyHashedPassword(user, userCheck.Password, user.PasswordAttempt);
if (result == 0)
{
// we have a problem
ModelState.AddModelError("Login.EmailAttempt", "Invalid Email/Password");
return(View("Index"));
}
else
{
// we made it!
HttpContext.Session.SetInt32("userId", userCheck.UserId);
return(RedirectToAction("Index", "Dashboard"));
}
}
}
return(View("Index"));
}
public async Task <IActionResult> AddUser(UserViewModel model)
{
var dbUser = await _dbContext.User.FirstOrDefaultAsync(x => x.Name == model.UserName);
if (dbUser != null)
{
return(Ok("用户已存在".Error()));
}
var newUser = new DashboardUser()
{
DisplayName = model.UserDisplayName,
Disabled = false,
HashPassword = model.Password.MD5Encrypt(),
InTime = DateTime.Now,
UpdateTime = DateTime.Now,
Name = model.UserName,
};
await _dbContext.User.AddAsync(newUser);
await _dbContext.SaveChangesAsync();
return(Ok(EmptyJson.Success()));
}
public IActionResult Create(LogRegModel model)
{
DashboardUser user = model.Register;
if (ModelState.IsValid)
{
// QUERY FOR UNIQUE EMAIL
if (dbContext.Users.Any(u => u.Email == user.Email))
{
// we have a problem
ModelState.AddModelError("Register.Email", "Email already in use!");
return(View("Index"));
}
// if all checks out, put them in the db!
PasswordHasher <DashboardUser> hasher = new PasswordHasher <DashboardUser>();
string hashedPw = hasher.HashPassword(user, user.Password);
user.Password = hashedPw;
dbContext.Users.Add(user);
dbContext.SaveChanges();
return(RedirectToAction("Index", "Dashboard"));
}
return(View("Index"));
}
private bool getDashboardStatus(Message message)
{
DashboardUserLogic dul = new DashboardUserLogic();
DashboardUser user = dul.GetByTelegramUserId(message.From.Id);
if (user == null)
{
return(false);
}
DashboardPermissionLogic dpl = new DashboardPermissionLogic();
DashboardPermission permission = dpl.GetByUserId(user.DashboardUserId,
CacheData.Groups[message.Chat.Id].GroupId);
if (permission == null)
{
return(false);
}
if (permission.State == DashboardPermission.Status.Active)
{
return(true);
}
return(false);
}
public DashboardUserViewModel(DashboardUser user)
{
if (user == null) throw new ArgumentNullException(nameof(user));
this.Name = user.Name;
this.Version = user.Version;
this.ReplicatedAt = user.ReplicatedAt.ToString(@"T");
}
public DashboardUser Update(DashboardUser dashboardUser, int callerId)
{
using (UBContext ubc = new UBContext())
{
DashboardUser exists = ubc.Group_DashboardUsers
.Where(x => x.DashboardUserId == dashboardUser.DashboardUserId)
.FirstOrDefault();
if (exists == null)
{
return(null);
}
try
{
exists.Name = dashboardUser.Name;
exists.ProfilePicture = dashboardUser.ProfilePicture;
exists.LastActionUtc = dashboardUser.LastActionUtc;
ubc.SaveChanges();
return(dashboardUser);
}
catch (Exception ex)
{
Utils.Logging.AddLog(new SystemLog()
{
LoggerName = "Unifiedban",
Date = DateTime.Now,
Function = "Unifiedban.Data.DashboardUserService.Update",
Level = SystemLog.Levels.Warn,
Message = ex.Message,
UserId = callerId
});
if (ex.InnerException != null)
{
Utils.Logging.AddLog(new SystemLog()
{
LoggerName = "Unifiedban.Data",
Date = DateTime.Now,
Function = "Unifiedban.Data.DashboardUserService.Update",
Level = SystemLog.Levels.Warn,
Message = ex.InnerException.Message,
UserId = callerId
});
}
}
return(null);
}
}
public static bool CanHandleGroup(string dashboardUserId, string groupId)
{
DashboardUser du = dul.GetById(dashboardUserId);
if (du == null)
{
return(false);
}
if (BotTools.IsUserOperator(du.TelegramUserId))
{
return(true);
}
return(dpl.GetGroups(dashboardUserId)
.SingleOrDefault(x => x.GroupId == groupId) != null);
}
public SystemLog.ErrorCodes Remove(DashboardUser dashboardUser, int callerId)
{
using (UBContext ubc = new UBContext())
{
DashboardUser exists = ubc.Group_DashboardUsers
.Where(x => x.DashboardUserId == dashboardUser.DashboardUserId)
.FirstOrDefault();
if (exists == null)
{
return(SystemLog.ErrorCodes.Error);
}
try
{
ubc.SaveChanges();
return(SystemLog.ErrorCodes.OK);
}
catch (Exception ex)
{
Utils.Logging.AddLog(new SystemLog()
{
LoggerName = "Unifiedban",
Date = DateTime.Now,
Function = "Unifiedban.Data.DashboardUserService.Remove",
Level = SystemLog.Levels.Warn,
Message = ex.Message,
UserId = callerId
});
if (ex.InnerException != null)
{
Utils.Logging.AddLog(new SystemLog()
{
LoggerName = "Unifiedban.Data",
Date = DateTime.Now,
Function = "Unifiedban.Data.DashboardUserService.Remove",
Level = SystemLog.Levels.Warn,
Message = ex.InnerException.Message,
UserId = callerId
});
}
}
return(SystemLog.ErrorCodes.Error);
}
}
public DashboardUser Add(DashboardUser dashboardUser, int callerId)
{
using (UBContext ubc = new UBContext())
{
try
{
ubc.Add(dashboardUser);
ubc.SaveChanges();
return(dashboardUser);
}
catch (Exception ex)
{
Utils.Logging.AddLog(new SystemLog()
{
LoggerName = "Unifiedban",
Date = DateTime.Now,
Function = "Unifiedban.Data.DashboardUserService.Add",
Level = SystemLog.Levels.Warn,
Message = ex.Message,
UserId = callerId
});
if (ex.InnerException != null)
{
Utils.Logging.AddLog(new SystemLog()
{
LoggerName = "Unifiedban.Data",
Date = DateTime.Now,
Function = "Unifiedban.Data.DashboardUserService.Add",
Level = SystemLog.Levels.Warn,
Message = ex.InnerException.Message,
UserId = callerId
});
}
}
return(null);
}
}
public IActionResult Create(DashboardUser user)
{
if (ModelState.IsValid)
{
if (dbContext.Users.Any(o => o.Email == user.Email))
{
ModelState.AddModelError("Email", "Email already in use");
return(View("Index"));
}
PasswordHasher <DashboardUser> hasher = new PasswordHasher <DashboardUser>();
user.Password = hasher.HashPassword(user, user.Password);
var newUser = dbContext.Users.Add(user).Entity;
dbContext.SaveChanges();
HttpContext.Session.SetInt32("userId", newUser.UserId);
HttpContext.Session.SetString("userName", newUser.FirstName);
return(RedirectToAction("Index", "Dashboard"));
}
return(View("Index"));
}
private void toggleDashboard(CallbackQuery callbackQuery)
{
Message message = callbackQuery.Message;
DashboardUserLogic dul = new DashboardUserLogic();
DashboardUser user = dul.GetByTelegramUserId(callbackQuery.From.Id);
if (user == null)
{
string profilePic = "";
var photos = Manager.BotClient.GetUserProfilePhotosAsync(callbackQuery.From.Id).Result;
if (photos.TotalCount > 0)
{
profilePic = photos.Photos[0][0].FileId;
}
user = dul.Add(callbackQuery.From.Id,
callbackQuery.From.FirstName + " " + callbackQuery.From.LastName,
profilePic, -2);
if (user == null)
{
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
ParseMode = ParseMode.Markdown,
Text = "*[Report]*\n" +
"Error enabling dashboard!"
});
return;
}
}
DashboardPermissionLogic dpl = new DashboardPermissionLogic();
DashboardPermission permission = dpl.GetByUserId(user.DashboardUserId,
CacheData.Groups[message.Chat.Id].GroupId);
if (permission == null)
{
if (dpl.Add(CacheData.Groups[message.Chat.Id].GroupId,
user.DashboardUserId, DashboardPermission.Status.Active,
-2) == null)
{
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
ParseMode = ParseMode.Markdown,
Text = "*[Report]*\n" +
"Error enabling dashboard!"
});
return;
}
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
ParseMode = ParseMode.Markdown,
Text = "Dashboard enabled!"
});
callbackQuery.Message.From.Id = callbackQuery.From.Id;
Execute(callbackQuery.Message, true);
return;
}
if (permission.State == DashboardPermission.Status.Banned)
{
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
ParseMode = ParseMode.Markdown,
Text = "*[Report]*\n" +
"Error: you are banned from the dashboard!"
});
return;
}
else if (permission.State == DashboardPermission.Status.Active)
{
permission.State = DashboardPermission.Status.Inactive;
}
else if (permission.State == DashboardPermission.Status.Inactive)
{
permission.State = DashboardPermission.Status.Active;
}
if (dpl.Update(permission, -2) == null)
{
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
ParseMode = ParseMode.Markdown,
Text = "*[Report]*\n" +
"Error enabling dashboard!"
});
}
else
{
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
ParseMode = ParseMode.Markdown,
Text = "Dashboard status updated!"
});
callbackQuery.Message.From.Id = callbackQuery.From.Id;
Execute(callbackQuery.Message, true);
}
}
