public async Task <IActionResult> Edit(string id, UserManagementModel model)
{
if (!await UserExists(id))
{
return(NotFound());
}
// TODO: make it seperate view model without those two fields, if you really want to :)
ModelState.Remove("Password");
ModelState.Remove("Id");
if (ModelState.IsValid)
{
ApplicationUser user = MapToModel(await applicationUserRepository.GetByID(id), model);
if (model.IsAdmin)
{
await userManager.AddToRoleAsync(user, ApplicationUser.AdminRole);
}
else
{
await userManager.RemoveFromRoleAsync(user, ApplicationUser.AdminRole);
}
await applicationUserRepository.UpdateAsync(user);
TempData["StatusMessage"] = "Account has been updated successfully.";
return(RedirectToAction(nameof(Index)));
}
return(View(model));
}
private UserManagementModel AdminModelHelper()
{
UserManagementModel model = new UserManagementModel();
model.NewAdmin = new UserModel();
model.AdminUsers = new List <UserModel>();
using (SqlConnection con = new SqlConnection(CS))
{
SqlCommand cmd = new SqlCommand("spGetAllAdminUsers", con);
cmd.CommandType = CommandType.StoredProcedure;
con.Open();
SqlDataReader sdr = cmd.ExecuteReader();
while (sdr.Read())
{
if (sdr["UserId"].ToString() != (string)TempData["UserId"])
{
UserModel user = new UserModel();
user.UserId = sdr["UserId"].ToString();
user.FirstName = sdr["FirstName"].ToString();
user.LastName = sdr["LastName"].ToString();
user.Email = sdr["Email"].ToString();
user.Phone = sdr["Phone"].ToString();
user.Password = "";
user.ConfirmPassword = "";
model.AdminUsers.Add(user);
}
}
}
return(model);
}
public IActionResult SignIn(string id, string password)
{
UserManagementModel userManagementModel
= new UserManagementModel(configuration);
string result = "";
int res = userManagementModel.SignIn(id, password, ref result);
ViewData["Result"] = result;
if (res == 0)
{
Microsoft.AspNetCore.Http.CookieOptions cookieOptions
= new Microsoft.AspNetCore.Http.CookieOptions()
{
Path = "/",
HttpOnly = true,
IsEssential = true,
Expires = DateTime.Now.AddHours(1),
};
Response.Cookies.Append("ID"
, Convert.ToBase64String(System.Text.Encoding.ASCII.GetBytes(id))
, cookieOptions);
return(RedirectToAction("Home", "Home"));
}
else
{
return(RedirectToAction("Entrance", "Main"));
}
}
public async Task <IActionResult> Create(UserManagementModel model)
{
if (ModelState.IsValid)
{
ApplicationUser user = MapToModel(new ApplicationUser(), model);
IdentityResult result = await userManager.CreateAsync(user, model.Password);
if (model.IsAdmin)
{
await userManager.AddToRoleAsync(user, ApplicationUser.AdminRole);
}
if (result.Succeeded)
{
TempData["StatusMessage"] = "New account has been created successfully.";
return(RedirectToAction(nameof(Index)));
}
foreach (IdentityError error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
return(View(model));
}
public JsonResult SaveSelectedCsvUser()
{
var userNames = Request["userNames"];
var emailIds = Request["emailIds"];
var allUsersList = new UserManagementModel().SaveuserBulkUpload(Request["AllUSerList"]);
return(Json(new { Data = new UserManagementModel().SubmitUsersBulkUpload(userNames, emailIds, allUsersList) }));
}
private ApplicationUser MapBasicInfo(ApplicationUser user, UserManagementModel model)
{
user.Email = model.Email;
user.FirstName = model.FirstName;
user.LastName = model.LastName;
user.PhoneNumber = model.PhoneNumber;
return(user);
}
public string UpdateUserIntoGroup()
{
var data = new List <string> {
Request["GroupUsers"], Request["GroupId"]
};
var addGroup = new UserManagementModel().AddUserinGroup(data);
return(addGroup);
}
public async Task <IActionResult> Manage(string id, UserManagementModel model)
{
ApplicationUser user = await userManager.FindByIdAsync(id);
if (user == null)
{
return(NotFound());
}
await applicationUserRepository.UpdateAsync(MapBasicInfo(user, model));
TempData["StatusMessage"] = "Your profile info have been updated.";
return(RedirectToAction(nameof(Manage)));
}
public string GetUsers()
{
var db = new Context();
var result = new List <UserManagementModel>();
var users = db.User.ToList();
foreach (var u in users)
{
var user = new UserManagementModel();
user.Id = u.Id;
user.Name = u.Name;
user.Email = u.Email;
user.Status = u.Active;
var roles = db.UserRole.Where(x => x.UserId == u.Id).ToList();
foreach (var r in roles)
{
if (user.Roles == string.Empty)
{
user.Roles = r.Role.Name;
}
else
{
user.Roles += ", " + r.Role.Name;
}
}
var facilities = db.UserFacility.Where(x => x.UserId == u.Id).ToList();
foreach (var f in facilities)
{
if (user.Facilities == string.Empty)
{
user.Facilities = f.Facility.Name;
}
else
{
user.Facilities += ", " + f.Facility.Name;
}
}
result.Add(user);
}
var response = JsonConvert.SerializeObject(result);
return(response);
}
public JsonResult PostAction()
{
var output = new Dictionary <string, string>();
JsonResult jsonOutput;
try
{
var userobj = new User
{
FirstName = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(Request["firstname"]),
LastName = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(Request["lastname"]),
UserName = Request["username"].ToLower(),
Email = Request["emailid"].ToLower()
};
userobj.DisplayName = (userobj.FirstName.Trim() + " " + userobj.LastName.Trim()).Trim();
userobj.Password = "******";
userobj.CreatedDate = DateTime.UtcNow;
userobj.ModifiedDate = DateTime.UtcNow;
userobj.TimeZone = GlobalAppSettings.SystemSettings.TimeZone;
userobj.IsActivated = false;
userobj.IsActive = false;
userobj.IsDeleted = false;
var activationCode = String.Empty;
var activationExpirationDate = new DateTime();
var result = userDetails.AddUser(userobj, out activationExpirationDate, out activationCode);
if (result.Status)
{
var activationUrl = GlobalAppSettings.SystemSettings.BaseUrl +
"/accounts/activate?ActivationCode=" +
activationCode;
const bool isResendActivationCode = false;
UserManagementModel.SendActivationCode(userobj.FirstName, userobj.UserName, userobj.Email,
activationUrl, activationExpirationDate, isResendActivationCode);
output.Add("result", "success");
jsonOutput = Json(new { Data = output });
}
else
{
output.Add("result", "error");
jsonOutput = Json(new { Data = output });
}
}
catch (Exception)
{
output.Add("result", "error");
jsonOutput = Json(new { Data = output });
}
return(jsonOutput);
}
public ResponseModel AddUserManagement(UserManagementModel userm)
{
ResponseModel res = new ResponseModel();
if (_customerBL.AddUserManagement(userm))
{
res.ErrorCode = 200;
res.Message = QueryResource.SuccessfulMsg;
}
else
{
res.ErrorCode = (int)HttpStatusCode.InternalServerError;
res.Message = QueryResource.InvalidResponse;
}
return(res);
}
public ActionResult UploadFileFormAction()
{
var result = "";
var userList = new List <Dictionary <string, string> >();
var uploadedCsvPath = "";
var httpPostedFileBase = Request.Files["csvfile"];
if (httpPostedFileBase != null && httpPostedFileBase.ContentLength > 0)
{
var fileName = httpPostedFileBase.FileName.Split('\\').Last();
var extension = Path.GetExtension(fileName);
var uploadedFilesPath = GlobalAppSettings.GetUploadedFilesPath();
if (Directory.Exists(uploadedFilesPath) == false)
{
Directory.CreateDirectory(uploadedFilesPath);
}
if (extension == ".csv")
{
uploadedCsvPath = String.Format("{0}\\{1}", uploadedFilesPath, fileName);
if (System.IO.File.Exists(uploadedCsvPath))
{
System.IO.File.Delete(uploadedCsvPath);
}
httpPostedFileBase.SaveAs(uploadedCsvPath);
userList = new UserManagementModel().SaveuserBulkUpload(uploadedCsvPath);
result = "Success";
}
else
{
result = "Error";
}
}
ViewBag.Pathname = uploadedCsvPath;
ViewBag.UsersList = Json(new { Data = userList });
ViewBag.UserExists = httpPostedFileBase != null && userList.Count == 0;
ViewBag.ser = GlobalAppSettings.Serializer.Serialize(ViewBag.UsersList);
ViewBag.UserCount = userList.Count;
ViewBag.result = result;
return(View());
}
protected bool CheckSigned(ref string message)
{
UserManagementModel model = new UserManagementModel(configuration);
string idBase64 = Request.Cookies["ID"];
if (!string.IsNullOrEmpty(idBase64))
{
string id = System.Text.Encoding.Default.GetString(Convert.FromBase64CharArray(
idBase64.ToCharArray(), 0, idBase64.Length));
if (!string.IsNullOrEmpty(id))
{
int result = model.SignIn(id, "", ref message);
return(result == 1 ? false : true);
}
}
return(false);
}
private ApplicationUser MapToModel(ApplicationUser user, UserManagementModel model)
{
user.Email = model.Email;
user.UserName = model.Email;
user.FirstName = model.FirstName;
user.LastName = model.LastName;
user.DateJoined = model.DateJoined;
user.VacationBalance = model.VacationBalance;
user.YearlyIncrement = model.YearlyIncrement;
user.GracePeriod = new TimeSpan(0, (int)model.GracePeriod, 0);
user.WorkStartTime = model.WorkStartTime;
user.WorkEndTime = model.WorkEndTime;
user.Salary = model.Salary;
user.PhoneNumber = model.PhoneNumber;
user.InsuranceDeduction = model.InsuranceDeduction;
user.HousingAllowance = model.HousingAllowance;
user.TransportationAllowance = model.TransportationAllowance;
user.CheckAttendance = model.CheckAttendance;
return(user);
}
public bool AddUserManagement(UserManagementModel objUserManagement)
{
using (var trans = _dbEntitites.Database.BeginTransaction())
{
try
{
//Adding customer
var customer = new Customer();
var user = new User();
if (objUserManagement.Id > 0)
{
customer = _dbEntitites.Customers.FirstOrDefault(x => x.Id == objUserManagement.Id);
user = _dbEntitites.Users.FirstOrDefault(x => x.Username == objUserManagement.Email);
}
//creating user for that customer
user.Username = objUserManagement.Email;
user.Password = "******";
user.RoleId = 3;
_dbEntitites.Users.AddOrUpdate(user);
customer.Name = objUserManagement.Name;
customer.Email = objUserManagement.Email;
customer.ContactNo = objUserManagement.ContactNo;
customer.CommunityName = objUserManagement.CommunityName;
customer.Type = objUserManagement.Type;
customer.ParentId = objUserManagement.ParentId;
//customer.UserId = objUserManagement.UserId;
_dbEntitites.Customers.AddOrUpdate(customer);
Save();
trans.Commit();
return(true);
}
catch (Exception ex)
{
trans.Rollback();
return(false);
}
}
}
public async Task <IActionResult> Admin(UserManagementModel managementModel)
{
if (ModelState.IsValid)
{
UserModel user = new UserModel(managementModel.NewAdmin);
UserLoginDetails details = new UserLoginDetails(user);
HttpResponseMessage response = await client.PostAsJsonAsync(FB_SignUp, details);
try {
response.EnsureSuccessStatusCode();
var responseBody = await response.Content.ReadAsAsync <SuccessResponse>();
user.UserId = responseBody.localId;
using (SqlConnection con = new SqlConnection(CS))
{
SqlCommand cmd = new SqlCommand("spAddNewUser", con);
cmd.CommandType = CommandType.StoredProcedure;
con.Open();
cmd.Parameters.AddWithValue("@UserId", user.UserId);
cmd.Parameters.AddWithValue("@FirstName", user.FirstName);
cmd.Parameters.AddWithValue("@LastName", user.LastName);
cmd.Parameters.AddWithValue("@Email", user.Email);
cmd.Parameters.AddWithValue("@Phone", user.Phone);
cmd.Parameters.AddWithValue("@Type", "Admin");
cmd.ExecuteNonQuery();
}
TempData["SuccessMessage"] = "Successfully created Admin user";
return(RedirectToAction("Admin"));
}
catch (HttpRequestException)
{
TempData["ErrorMessage"] = "Something went wrong. Please try again later";
return(RedirectToAction("Admin"));
}
}
return(View(managementModel));
}
public async Task <IActionResult> Manage()
{
User thisUser = await userManager.GetUserAsync(HttpContext.User);
var allUsers = dataRepository.GetAllUsersExcept(thisUser);
List <UserManagementModel> accessUsers = new List <UserManagementModel>();
var admins = await userManager.GetUsersInRoleAsync("Admin");
foreach (User assessUser in allUsers)
{
UserManagementModel managedUser = new UserManagementModel
{
ID = assessUser.Id,
Avatar = assessUser.UserAvatar,
UserName = assessUser.UserName,
Name = assessUser.FirstName + " " + assessUser.LastName,
IsAdmin = admins.Select(u => u.Id).Contains(assessUser.Id)
};
accessUsers.Add(managedUser);
}
logger.LogInformation("Admin " + thisUser.UserName + " navigated to manage users Page");
return(View(accessUsers));
}
public async Task Insert(UserManagementModel userManagementModel)
{
await userManagementService.Insert(userManagementModel);
}
public JsonResult ActivateUser()
{
var userId = userDetails.GetUserId(Request["username"]);
var output = new Dictionary <string, string>();
JsonResult jsonOutput;
try
{
var userobj = new User
{
FirstName = Request["firstname"],
UserName = Request["username"],
Email = Request["email"],
ActivationCode = userDetails.GenerateRandomCode(12),
ActivationExpirationDate =
DateTime.UtcNow.AddDays(GlobalAppSettings.SystemSettings.ActivationExpirationDays)
};
const bool isResendActivationCode = false;
var activationUrl = GlobalAppSettings.SystemSettings.BaseUrl + "/accounts/activate?ActivationCode=" +
userobj.ActivationCode;
var updateColumns = new List <UpdateColumn>
{
new UpdateColumn
{
ColumnName = GlobalAppSettings.DbColumns.DB_User.ModifiedDate,
Value = DateTime.UtcNow.ToString(GlobalAppSettings.GetDateTimeFormat())
},
new UpdateColumn
{
ColumnName = GlobalAppSettings.DbColumns.DB_User.ActivationCode,
Value = userobj.ActivationCode
},
new UpdateColumn
{
ColumnName = GlobalAppSettings.DbColumns.DB_User.ActivationExpirationDate,
Value = userobj.ActivationExpirationDate.ToString(GlobalAppSettings.GetDateTimeFormat())
}
};
var result = userDetails.UpdateUserProfileDetails(updateColumns, userId);
if (result)
{
UserManagementModel.SendActivationCode(userobj.FirstName, userobj.UserName, userobj.Email,
activationUrl, userobj.ActivationExpirationDate, isResendActivationCode);
output.Add("result", "success");
jsonOutput = Json(new { Data = output });
}
else
{
output.Add("result", "error");
jsonOutput = Json(new { Data = output });
}
}
catch (Exception)
{
output.Add("result", "error");
jsonOutput = Json(new { Data = output });
}
return(jsonOutput);
}
public JsonResult GetAllUserList(int?skip, int?take, string searchKey, List <SortCollection> sorted, List <FilterCollection> filterCollection)
{
return(Json(UserManagementModel.GetAllUserList(skip, take, searchKey, sorted, filterCollection)));
}
public async Task Insert(UserManagementModel userManagementModel)
{
await context.User.AddAsync(userManagementModel);
await context.SaveChangesAsync();
}
public async Task Update(UserManagementModel userManagementModel)
{
context.Update(userManagementModel);
context.SaveChanges();
}
public bool AddUserManagement(UserManagementModel userModel)
{
return(_userm.AddUserManagement(userModel));
}
public async Task Update(UserManagementModel userManagementModel)
{
await userManagementService.Update(userManagementModel);
}
