public Task <IResult <string> > SignInAsync(SignInModel signInModel)
{
var validation = new SignInModelValidator().Valid(signInModel);
if (!validation.Success)
{
return(Task.FromResult(validation));
}
var signedInModel = UserRepository.SignInAsync(signInModel).Result;
validation = new SignedInModelValidator().Valid(signedInModel);
if (!validation.Success)
{
return(Task.FromResult(validation));
}
var userLogModel = new UserLogModel(signedInModel.UserId, LogType.Login);
UserLogDomain.SaveAsync(userLogModel);
var jwt = CreateJwt(signedInModel);
IResult <string> successResult = new SuccessResult <string>(jwt);
return(Task.FromResult(successResult));
}
public IActionResult updateUserLog([FromBody] UserLogModel request)
{
try {
User currentUser = _userService.CheckUseRole(_httpContextAccessor.HttpContext.User, menu, "update");
if (currentUser != null)
{
UserLogModel model = _context.Userlogs.FirstOrDefault(p => p.SN == request.SN);
model.Username = request.Username;
model.Datetime = request.Datetime;
model.Activity = request.Activity;
model.Type = request.Type;
model.Event = request.Event;
_context.SaveChanges();
_eventService.SaveEvent(currentUser.User_Id, EventUserLog.EVENT_UPDATE, EventUserLog.ACTIVITY_SUCCESS, "UserLog");
return(Ok(model));
}
else
{
return(Ok(SendResult.SendError("You don`t have update permision.")));
}
} catch (Exception error) {
Console.WriteLine(error);
return(BadRequest(SendResult.SendError("You don`t update UserLog info")));
}
}
public async Task <IDataResult <TokenModel> > SignInAsync(SignInModel signInModel)
{
var validation = new SignInModelValidator().Validate(signInModel);
if (validation.Failed)
{
return(DataResult <TokenModel> .Fail(validation.Message));
}
var signedInModel = await _userRepository.SignInAsync(signInModel);
validation = _signInService.Validate(signedInModel, signInModel);
if (validation.Failed)
{
return(DataResult <TokenModel> .Fail(validation.Message));
}
var userLogModel = new UserLogModel(signedInModel.Id, LogType.SignIn);
await _userLogApplicationService.AddAsync(userLogModel);
var tokenModel = _signInService.CreateToken(signedInModel);
return(DataResult <TokenModel> .Success(tokenModel));
}
public void Save(UserLogModel userLogModel)
{
var userLogEntity = userLogModel.Map <UserLogEntity>();
UserLogRepository.Add(userLogEntity);
DatabaseUnitOfWork.SaveChanges();
}
public IActionResult ProcessLogin(UserLogModel LoginAttempt)
{
if (ModelState.IsValid)
{
User EmailCheck = _context.users.SingleOrDefault(user => user.Email == LoginAttempt.Email);
if (EmailCheck == null)
{
ModelState.AddModelError("Email", "Invalid login attempt");
}
else
{
PasswordHasher <User> Hasher = new PasswordHasher <User>();
if (0 != Hasher.VerifyHashedPassword(EmailCheck, EmailCheck.Password, LoginAttempt.Password))
{
HttpContext.Session.SetInt32("id", EmailCheck.UserId);
HttpContext.Session.SetString("name", EmailCheck.FirstName + ' ' + EmailCheck.LastName);
HttpContext.Session.SetInt32("permission", EmailCheck.PermissionLevel);
return(RedirectToAction("Dashboard"));
}
else
{
ModelState.AddModelError("Email", "Invalid login attempt");
}
}
}
ViewBag.LoggedIn = false;
return(View("Login", LoginAttempt));
}
public IList <UserLogModel> GetUserLog(string ip)
{
List <UserLogModel> userLogs = new List <UserLogModel>();
using (SqlConnection cn = new SqlConnection(connectionString))
{
cn.Open();
SqlCommand cmd = new SqlCommand(
"SELECT UserIp, Date, cw.UserId, Word, w.ID FROM Words w inner join CachedWords cw on w.Id = cw.AnagramID inner join UserLog u on u.UserIP = @word ORDER BY Date",
cn);
cmd.Parameters.Add("@word", SqlDbType.NVarChar);
cmd.Parameters["@word"].Value = ip;
SqlDataReader reader = cmd.ExecuteReader();
while (reader.Read())
{
UserLogModel logModel = new UserLogModel()
{
UserIp = ip,
Date = (DateTime)reader["Date"],
Id = (int)reader["Id"],
};
userLogs.Add(logModel);
}
cn.Close();
}
return(userLogs);
}
public async Task <IDataResult <TokenModel> > SignInAsync(SignInModel signInModel)
{
var validation = new SignInModelValidator().Valid(signInModel);
if (!validation.Success)
{
return(new ErrorDataResult <TokenModel>(validation.Message));
}
var signedInModel = await UserRepository.SignInAsync(signInModel);
if (!SignInService.Validate(signedInModel, signInModel))
{
return(new ErrorDataResult <TokenModel>(Texts.LoginPasswordInvalid));
}
var userLogModel = new UserLogModel(signedInModel.UserId, LogType.SignIn);
await UserLogApplicationService.AddAsync(userLogModel);
await UnitOfWork.SaveChangesAsync();
var tokenModel = SignInService.CreateToken(signedInModel);
return(new SuccessDataResult <TokenModel>(tokenModel));
}
public async Task <IDataResult <TokenModel> > SignInAsync(SignInModel signInModel)
{
var validation = new SignInModelValidator().Validate(signInModel);
if (validation.IsError)
{
return(DataResult <TokenModel> .Error(validation.Message));
}
var signedInModel = await UserRepository.SignInAsync(signInModel);
validation = SignInService.Validate(signedInModel, signInModel);
if (validation.IsError)
{
return(DataResult <TokenModel> .Error(validation.Message));
}
var userLogModel = new UserLogModel(signedInModel.Id, LogType.SignIn);
await UserLogApplicationService.AddAsync(userLogModel);
await UnitOfWork.SaveChangesAsync();
var tokenModel = SignInService.CreateToken(signedInModel);
return(DataResult <TokenModel> .Success(tokenModel));
}
public IResult <string> SignIn(SignInModel signInModel)
{
var signInModelValidator = new SignInModelValidator().Valid(signInModel);
if (!signInModelValidator.Success)
{
return(signInModelValidator);
}
var signedInModel = UserRepository.SignIn(signInModel);
var signedInModelValidator = new SignedInModelValidator().Valid(signedInModel);
if (!signedInModelValidator.Success)
{
return(signedInModelValidator);
}
var userLogModel = new UserLogModel(signedInModel.UserId, LogType.Login);
UserLogDomain.Save(userLogModel);
var jwt = CreateJwt(signedInModel);
return(new SuccessResult <string>(jwt));
}
//update ip address
public int UpdateIpAddress(UserLogModel ipModel)
{
int res = 0;
try
{
using (TransactionScope trScope = new TransactionScope())
{
using (SqlConnection con = new SqlConnection(CONNECTION_STRING))
{
con.Open();
SqlCommand command = new SqlCommand("Update_UserIp", con);
command.CommandType = CommandType.StoredProcedure;
command.Parameters.AddWithValue("@User_Id", ipModel.UserId);
command.Parameters.AddWithValue("@UserAgent", ipModel.UserAgent);
command.Parameters.AddWithValue("@IpAddress", ipModel.UserIpAddress);
res = Convert.ToInt32(command.ExecuteScalar());
}
trScope.Complete();
}
}
catch
{
throw;
}
return(res);
}
public Task AddAsync(UserLogModel userLogModel)
{
var userLogEntity = userLogModel.Map <UserLogEntity>();
UserLogRepository.AddAsync(userLogEntity);
return(DatabaseUnitOfWork.SaveChangesAsync());
}
public async Task AddAsync(UserLogModel userLogModel)
{
var userLogEntity = UserLogFactory.Create(userLogModel);
await _userLogRepository.AddAsync(userLogEntity);
await _unitOfWork.SaveChangesAsync();
}
public async Task SignOutAsync(SignOutModel signOutModel)
{
var userLogModel = new UserLogModel(signOutModel.Id, LogType.SignOut);
await UserLogApplicationService.AddAsync(userLogModel);
await UnitOfWork.SaveChangesAsync();
}
public UserLogModel GetUserLogIp()
{
var model = new UserLogModel();
model.UserIpAddress = HttpContext.Current.Request.UserHostAddress;
model.UserAgent = HttpContext.Current.Request.UserAgent;
//var CalledUrl = HttpContext.Current.Request.Url.OriginalString;
return(model);
}
public static UserLogEntity Create(UserLogModel userLogModel)
{
if (userLogModel is null)
{
throw new ArgumentNullException(nameof(userLogModel));
}
return(new UserLogEntity(userLogModel.UserId, userLogModel.LogType));
}
public void Update(UserLogModel model)
{
using (var dbContext = dbContextFactory.CreateDbContext())
{
var entity = UserLogMapper.ModelToEntity(model);
dbContext.UserLogs.Update(entity);
dbContext.SaveChanges();
}
}
public UserLogModel Create(UserLogModel model)
{
using (var dbContext = dbContextFactory.CreateDbContext())
{
var entity = UserLogMapper.ModelToEntity(model);
dbContext.UserLogs.Add(entity);
dbContext.SaveChanges();
return(UserLogMapper.EntityToModel(entity));
}
}
public static UserLogDomain Create(UserLogModel userLogModel)
{
return(new UserLogDomain
(
userLogModel.UserLogId,
userLogModel.UserId,
userLogModel.LogType,
userLogModel.Content,
userLogModel.DateTime
));
}
public async Task AddAsync(UserLogModel userLogModel)
{
var userLogDomain = UserLogDomainFactory.Create(userLogModel);
userLogDomain.Add();
var userLogEntity = UserLogEntityFactory.Create(userLogDomain);
await UserLogRepository.AddAsync(userLogEntity);
await DatabaseUnitOfWork.SaveChangesAsync();
}
public void Save(long userId, LogType logType)
{
var userLog = new UserLogModel
{
UserId = userId,
LogType = logType,
DateTime = DateTime.UtcNow
};
DatabaseUnitOfWork.UserLogRepository.Add(userLog);
DatabaseUnitOfWork.SaveChanges();
}
public void Save(long userId, LogType logType)
{
var userLog = new UserLogModel
{
UserId = userId,
LogType = logType,
DateTime = DateTime.UtcNow
};
Database.UserLog.Add(userLog);
Database.SaveChanges();
}
private void SaveUserLog(long userId, LogType logType)
{
var userLog = new UserLogModel
{
UserId = userId,
LogType = logType,
DateTime = DateTime.Now
};
DatabaseUnitOfWork.UserLogRepository.Add(userLog);
DatabaseUnitOfWork.Commit();
}
// POST api/userlogs
public IHttpActionResult Post([FromBody] UserLogModel userLog)
{
var id = LogUserActivity(userLog);
if (id == 0)
{
return(NotFound());
}
userLog.Id = id;
return(Ok(userLog));
}
public async Task SignOutAsync(SignOutModel signOutModel)
{
if (signOutModel is null)
{
throw new ArgumentNullException(nameof(signOutModel));
}
var userLogModel = new UserLogModel(signOutModel.Id, LogType.SignOut);
await _userLogApplicationService.AddAsync(userLogModel).ConfigureAwait(false);
await _unitOfWork.SaveChangesAsync().ConfigureAwait(false);
}
public static UserLog ModelToEntity(UserLogModel model)
{
if (model == null)
{
return(null);
}
return(new UserLog
{
Id = model.Id,
Action = model.Action,
Timestamp = model.Timestamp,
});
}
public void StoreUserInfo(UserLogModel receivedUserLog)
{
var splitInput = receivedUserLog.SearchedWord.Split(" ");
var userLog = new UserLog();
foreach (string word in splitInput)
{
userLog = new UserLog();
userLog.UserIp = receivedUserLog.IPAdress;
userLog.SearchTime = receivedUserLog.SearchTime;
userLog.UserSearchedWord = word;
db.UserLog.Add(userLog);
db.SaveChanges();
}
}
public void InsertUserLog(string UserID, string PageName, string OperationName, bool MobileView)
{
UserLogModel userLogModel = new UserLogModel();
userLogModel.MobileView = MobileView;
userLogModel.OperationName = OperationName;
userLogModel.PageName = PageName;
userLogModel.UserId = UserID;
var tempmapper = _mapper;
var model = _mapper.Map <UserLog>(userLogModel);
model.OperationDate = DateTime.Now;
unitOfWork.UserLogRepository.Insert(model);
unitOfWork.Save();
}
public void SaveEvent(int userName, string eventName, string activity, string type)
{
try {
UserLogModel model = new UserLogModel {
Username = userName,
Event = eventName,
Activity = activity,
Type = type,
Datetime = DateTime.Now
};
_context.Add(model);
_context.SaveChanges();
} catch (Exception error) {
Console.WriteLine(error);
}
}
/// <summary>
/// 用户登录
/// </summary>
/// <param name="user">用户登录信息</param>
/// <returns></returns>
public UserLogModel UserLogin(UserLogModel user)
{
using (IDbConnection conn = new SqlConnection(connStr))
{
string sql = @"SELECT u.UserId, u.UserName,r.RoleName,p.privilegeName FROM dbo.UserInfo u
JOIN dbo.UserRoleMapInfo m ON u. UserId = m.UserId
JOIN dbo.RoleInfo r ON m.RoleId = r.RoleId
JOIN dbo.RolePrivilegeMapInfo m2 ON m2.RoleId=r.RoleId
JOIN dbo.PrivilegeInfo p ON p.PrivilegeId=m2.PrivilegeId
WHERE UserName = @username AND UserPassword = @userpassword";
//获取用户信息并返回
var userinfo = conn.QueryFirstOrDefault <UserLogModel>(sql, new { username = user.UserName, userpassword = user.UserPassword });
return(userinfo);
}
}
public string SignIn(SignInModel signInModel)
{
new SignInModelValidator().ValidateThrow(signInModel);
TransformLoginAndPasswordToHash(signInModel);
var signedInModel = UserRepository.SignIn(signInModel);
new SignedInModelValidator().ValidateThrow(signedInModel);
var userLogModel = new UserLogModel(signedInModel.UserId, LogType.Login);
UserLogDomain.Save(userLogModel);
return(CreateJwt(signedInModel));
}
