public EmployeeController(EmployeeLogin employeeLogin, IEmployeeRepository employeeRepository, IPositionNameRepository positionNameRepository, SendEmail sendEmail)
{
_employeeLogin = employeeLogin;
_employeeRepository = employeeRepository;
_positionNameRepository = positionNameRepository;
_sendEmail = sendEmail;
}
public ActionResult Login(LoginModel model)
{
if (ModelState.IsValid)
{
var dao = new EmployeeDao();
var result = dao.Login(model.Email, Encryptor.MD5Hash(model.Password));
if (result == 1)
{
var employee = dao.GetByEmail(model.Email);
var employeeSession = new EmployeeLogin();
Session["empname"] = dao.GetByEmail(model.Email).EmployeeName;
employeeSession.EmployeeName = employee.EmployeeName;
employeeSession.Email = employee.Email;
Session.Add(CommonConstants.EMPLOYEE_SESSION, employeeSession);
Session["Account"] = employee.EmployeeName;
Session["Image"] = employee.Image;
return(RedirectToAction("Index", "Home"));
}
else if (result == 0)
{
ModelState.AddModelError("", "This account does not exsits");
}
else if (result == -1)
{
ModelState.AddModelError("", "This account was locked");
}
else if (result == -2)
{
ModelState.AddModelError("", "Incorect email or password");
}
}
return(View("Index"));
}
private void btnLogout_Click(object sender, EventArgs e)
{
EmployeeLogin login = new EmployeeLogin();
this.Hide();
login.Show();
}
public async Task PostEmployeeLogin_DifferentUsersLogInWithSameStationId_ReturnsUnathorizedToSecondUser()
{
using (var context = GetInitializedUsersContext())
{
var usersService = new Services.UsersService(context, new QueueApiServiceMock());
UsersController controller = new UsersController(usersService);
EmployeeLogin login = new EmployeeLogin
{
Username = "******",
Password = "******",
ServiceType = ServiceType.Pharmacist,
StationNumber = 1
};
ActionResult <EmployeeInfo> firstLogin = await controller.PostEmployeeLogin(login);
EmployeeLogin loginWithSameStationId = new EmployeeLogin
{
Username = "******",
Password = "******",
ServiceType = ServiceType.Pharmacist,
StationNumber = 1
};
ActionResult <EmployeeInfo> result = await controller.PostEmployeeLogin(loginWithSameStationId);
Assert.IsInstanceOf <ActionResult <EmployeeInfo> >(result);
Assert.IsInstanceOf <UnauthorizedObjectResult>(result.Result);
Assert.IsNull(result.Value);
}
}
public ActionResult ELogin(ViewUserLogin vUserLogin)
{
if (ModelState.IsValid)
{
EmployeeLoginRepository loginRepo = new EmployeeLoginRepository();
EmployeeLogin login = new EmployeeLogin();
login.Username = vUserLogin.Username;
login.Password = vUserLogin.Password;
EmployeeLogin loginFromDb = loginRepo.Match(login);
if (loginFromDb.EmployeeType == "Admin")
{
return(RedirectToAction("LoadAdmin", "Employee", new { @id = loginFromDb.Id }));
}
else if (loginFromDb.EmployeeType == "Mama")
{
return(RedirectToAction("LoadMama", "Employee", new { @id = loginFromDb.Id }));
}
else
{
return(View("Error"));
}
}
else
{
return(View("EmployeeLogin", vUserLogin));
}
}
/// <summary>
/// This method will use a STP server in order to send the user a email.
/// </summary>
/// <param name="emp"></param>
/// <returns></returns>
private bool SendEmail(EmployeeLogin emp)
{
MailMessage msg = new MailMessage("*****@*****.**", emp.Username)
{
Subject = "Password Recovery",
Body = "Hello " + emp.Username + Environment.NewLine + " Please use the following link to reset your account: http://localhost:56163/Account/Reset "
};
NetworkCredential creds = new NetworkCredential("*****@*****.**", "hci12345");
SmtpClient mailClient = new SmtpClient
{
Port = 587,
Host = "smtp.gmail.com",
UseDefaultCredentials = false,
Credentials = creds,
DeliveryMethod = SmtpDeliveryMethod.Network,
EnableSsl = true
};
try
{
//try send email
mailClient.Send(msg);
Debug.WriteLine("Email has been sent");
return(true);
}
catch (Exception)
{
//if fails catch the exeception and return false for caller to handle
return(false);
}
}
EmployeeLogin IEmployeeDA.SaveEmployeedetails(M_Employee employee)
{
DataTable dt = new DataTable();
EmployeeLogin empResp = new EmployeeLogin();
if (connString.State == ConnectionState.Closed)
{
connString.Open();
}
cmd = new SqlCommand("uspInsertNewEmployee", connString);
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@FistName", employee.FirstName);
cmd.Parameters.AddWithValue("@LastName", employee.LastName);
cmd.Parameters.AddWithValue("@UserName", employee.UserName);
cmd.Parameters.AddWithValue("@Password", employee.Password);
cmd.Parameters.AddWithValue("@Email", employee.Email);
cmd.Parameters.AddWithValue("@Mobile", employee.Mobile);
cmd.Parameters.AddWithValue("@Address", employee.Address);
cmd.Parameters.AddWithValue("@CreatedBy", 1);
SqlDataAdapter sda = new SqlDataAdapter(cmd);
sda.Fill(dt);
sda.Dispose();
connString.Close();
empResp = ExtensionMethods.ConvertToListOf <EmployeeLogin>(dt)[0];
return(empResp);
}
public ActionResult Create(EmployeeVM employee)
{
if (ModelState.IsValid)
{
var parkEmployee = new ParkEmployee();
parkEmployee.FirstName = employee.FirstName;
parkEmployee.LastName = employee.LastName;
parkEmployee.MiddleName = employee.MiddleName;
parkEmployee.StreetAddress = employee.StreetAddress;
parkEmployee.City = employee.City;
parkEmployee.State = employee.State;
parkEmployee.ZipCode = employee.ZipCode;
parkEmployee.PhoneNumber = employee.PhoneNumber;
parkEmployee.DateOfBirth = employee.DateOfBirth;
parkEmployee.Sex = employee.Sex;
parkEmployee.JobTitle = employee.JobTitle;
parkEmployee.DepartmentID = employee.DepartmentID;
var login = new EmployeeLogin();
login.ParkEmployee = parkEmployee;
login.LoginEmail = employee.LoginEmail;
login.Pswd = employee.Pswd;
db.ParkEmployees.Add(parkEmployee);
db.EmployeeLogins.Add(login);
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.DepartmentID = new SelectList(db.Departments, "DepartmentID", "DName", employee.DepartmentID);
return(View(employee));
}
public ActionResult SignUp(EmployeeRegisterView regEmp)
{
using (GerGarageDbEntities db = new GerGarageDbEntities())
{
EmployeeRegistry emp = new EmployeeRegistry();
emp.EmployeeFirstName = regEmp.EmployeeFirstName;
emp.EmployeeLastName = regEmp.EmployeeLastName;
emp.EmployeeContact = regEmp.EmployeeContact;
emp.EmployeeEmailId = regEmp.EmployeeEmailId;
emp.EmployeePassword = regEmp.EmployeePassword;
EmployeeLogin logEmp = new EmployeeLogin();
logEmp.EmployeeEmailId = regEmp.EmployeeEmailId;
logEmp.EmployeePassword = regEmp.EmployeePassword;
if (ModelState.IsValid)
{
db.EmployeeRegistries.Add(emp);
db.EmployeeLogins.Add(logEmp);
db.SaveChanges();
return(RedirectToAction("Login"));
}
return(View());
}
}
protected override ValidationResult IsValid(object value, ValidationContext validationContext)
{
string cpf = value as string;
if (!ValidationCpfOrCnpj.ValidationCpfOrCnpj.IsCpf(cpf))
{
return(new ValidationResult(Message.MSG_CPF_Invalido));
}
IClientRepository repository = (IClientRepository)validationContext.GetService(typeof(IClientRepository));
EmployeeLogin login = (EmployeeLogin)validationContext.GetService(typeof(EmployeeLogin));
List <ClientPhysical> list = (List <ClientPhysical>)repository.FindByCpf(cpf, login.GetEmployee().BusinessId);
ClientPhysical client = (ClientPhysical)validationContext.ObjectInstance;
if (list.Count > 1)
{
return(new ValidationResult(Message.MSG_CPF_Cadastrado));
}
if (list.Count == 1 && list[0].Id != client.Id)
{
return(new ValidationResult(Message.MSG_CPF_Cadastrado));
}
return(ValidationResult.Success);
}
// POST: odata/EmployeeLogins
public IHttpActionResult Post(EmployeeLogin employeeLogin)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.EmployeeLogins.Add(employeeLogin);
try
{
db.SaveChanges();
}
catch (DbUpdateException)
{
if (EmployeeLoginExists(employeeLogin.loginId))
{
return(Conflict());
}
else
{
throw;
}
}
return(Created(employeeLogin));
}
/// <summary>
/// this method will allow a developer to log there actions in the controllers as they are made it will create a record
/// in the database when this method is called.
/// </summary>
/// <param name="actionType"></param>
/// <param name="message"></param>
/// <param name="empLog"></param>
public static void LogAction(string actionType, string message, EmployeeLogin empLog = null)
{
//Log log;
//DatabaseContext _context = new DatabaseContext();
//if (empLog == null)
//{
// log = new Log()
// {
// EmployeeLoginId = CurrentUser.EmployeeLogin.EmployeeLoginId,
// DateOfAction = DateTime.Now,
// ActionType = _context.ActionTypes.FirstOrDefault(a => a.Description == actionType),
// PropertyEffected = message
// };
//}
//else
//{
// log = new Log()
// {
// EmployeeLoginId = empLog.EmployeeLoginId,
// DateOfAction = DateTime.Now,
// ActionType = _context.ActionTypes.FirstOrDefault(a => a.Description == actionType),
// PropertyEffected = message
// };
//}
//_context.Logs.Add(log);
//_context.SaveChanges();
//_context.Dispose();
}
public object InsertEmployee(Register Reg)
{
try
{
EmployeeLogin EL = new EmployeeLogin();
if (EL.Id == 0)
{
EL.EmployeeName = Reg.EmployeeName;
EL.City = Reg.City;
EL.Email = Reg.Email;
EL.Password = Reg.Password;
EL.Department = Reg.Department;
DB.EmployeeLogins.Add(EL);
DB.SaveChanges();
return(new Response
{
Status = "Success", Message = "Sucessfully saved to database."
});
}
}
catch (Exception)
{
throw;
}
return(new Response
{
Status = "Error", Message = "Invalid Data"
});
}
public EmployeeLogin SaveEmployee(M_Employee employee)
{
EmployeeLogin obj = new EmployeeLogin();
obj = iempDa.SaveEmployeedetails(employee);
return(obj);
}
protected override ValidationResult IsValid(object value, ValidationContext validationContext)
{
string cpf = (value as string).Trim();
if (!ValidationCpfOrCnpj.ValidationCpfOrCnpj.IsCpf(cpf))
{
return(new ValidationResult("CPF inválido"));
}
IEmployeeRepository repository = (IEmployeeRepository)validationContext.GetService(typeof(IEmployeeRepository));
EmployeeLogin login = (EmployeeLogin)validationContext.GetService(typeof(EmployeeLogin));
Models.Employee employee = (Models.Employee)validationContext.ObjectInstance;
List <Models.Employee> list = repository.FindByCpf(cpf, login.GetEmployee().BusinessId).ToList();
if (list.Count > 1)
{
return(new ValidationResult("CPF já cadastrado"));
}
if (list.Count == 1 && list[0].Id != employee.Id)
{
return(new ValidationResult("CPF já cadastrado"));
}
return(ValidationResult.Success);
}
public EmployeeLogin AddLogins(EmployeeLogin emp)
{
_context.EmployeeLogins.Add(emp);
_context.SaveChangesAsync();
return(emp);
}
public async Task <IActionResult> PutEmployeeLogin(int id, EmployeeLogin employeeLogin)
{
if (id != employeeLogin.Id)
{
return(BadRequest());
}
_context.Entry(employeeLogin).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EmployeeLoginExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> Edit(decimal id, [Bind("EmployeeLoginId,EmpId,Pass")] EmployeeLogin employeeLogin)
{
if (id != employeeLogin.EmployeeLoginId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(employeeLogin);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EmployeeLoginExists(employeeLogin.EmployeeLoginId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["EmpId"] = new SelectList(_context.Employee, "EmpId", "EmpId", employeeLogin.EmpId);
return(View(employeeLogin));
}
public DiscountController(IDiscountStock discountStock, IStockRepository stockRepository,
IDiscountProductStockRepository discountProductStock, EmployeeLogin employeeLogin)
{
_discountStock = discountStock;
_employeeLogin = employeeLogin;
_discountProductStock = discountProductStock;
_stockRepository = stockRepository;
}
public ProductController(IProductRepository productRepository, ICategoryRepository categoryRepository, ICategoryProductRepository categoryProductRepository,
EmployeeLogin employeeLogin)
{
_productRepository = productRepository;
_categoryRepository = categoryRepository;
_categoryProductRepository = categoryProductRepository;
_employeeLogin = employeeLogin;
}
public int Delete(int id)
{
EmployeeLogin EmployeeLoginToDelete = context.EmployeeLogins.SingleOrDefault(a => a.Id == id);
context.EmployeeLogins.Remove(EmployeeLoginToDelete);
return(context.SaveChanges());
}
public ActionResult DeleteConfirmed(int id)
{
EmployeeLogin employeeLogin = db.EmployeeLogins.Find(id);
db.EmployeeLogins.Remove(employeeLogin);
db.SaveChanges();
return(RedirectToAction("Index"));
}
private void EmployeeButton_Click_1(object sender, RoutedEventArgs e)
{
EmployeeLogin employee = new EmployeeLogin();
employee.Show();
Close();
// cinema_hall_management_system.UI.EmployeeLogin emp = new cinema_hall_management_system.UI.EmployeeLogin();
}
public int Update(EmployeeLogin employeeLogin)
{
EmployeeLogin employeeLoginToUpdate = context.EmployeeLogins.SingleOrDefault(a => a.Id == employeeLogin.Id);
employeeLoginToUpdate.Password = employeeLogin.Password;
employeeLoginToUpdate.Username = employeeLogin.Username;
return(context.SaveChanges());
}
public PurchaseController(IPurchaseOrderRepository purchaseOrderRepository, EmployeeLogin employeeLogin, ISupplierRepository supplierRepository,
IProductRepository productRepository, InventoryManagement inventoryManagement)
{
_purchaseOrderRepository = purchaseOrderRepository;
_employeeLogin = employeeLogin;
_supplierRepository = supplierRepository;
_productRepository = productRepository;
_inventoryManagement = inventoryManagement;
}
public void OnAuthorization(AuthorizationFilterContext context)
{
_employeeLogin = (EmployeeLogin)context.HttpContext.RequestServices.GetService(typeof(EmployeeLogin));
if (_employeeLogin.GetEmployee() == null)
{
context.Result = new RedirectToActionResult("Index", "Home", new { Area = "" });
}
}
public string UpdatePassword(EmployeeLogin emp)
{
//int id = _context.EmployeeLogins.Where(e => e.Email == email).Select(i=>i.Id).FirstOrDefault();
var data = _context.EmployeeLogins.First(a => a.Email == emp.Email);
data.Password = emp.Password;
_context.SaveChangesAsync();
return("New password Updated Successfully");
}
public async Task <ActionResult <EmployeeLogin> > PostEmployeeLogin(EmployeeLogin employeeLogin)
{
_context.EmployeeLogins.Add(employeeLogin);
Console.WriteLine("true");
await _context.SaveChangesAsync();
return(employeeLogin);
}
public ActionResult RegisterForm(RegisterViewModel registerVm)
{
var users = _context.EmployeeLogins.ToList();
var checkifExist = _context.EmployeeLogins.FirstOrDefault(e => e.Username == registerVm.Email);
if (checkifExist != null)
{
return(View("Register"));
}
if (registerVm.Password != registerVm.ReTypePasssword)
{
return(View("Register"));
}
var employee = _context.Employees.FirstOrDefault(e => e.EmployeeNumber == registerVm.EmployeeNumber);
if (employee == null)
{
return(View("Register"));
}
if (employee.AccountCreated)
{
return(View("Register"));
}
var returned = Encryptor.Encrypt(registerVm.Password);
EmployeeLogin emp = new EmployeeLogin()
{
Username = registerVm.Email,
Password = returned[0],
Salt = returned[1],
EmployeeId = employee.EmployeeId,
CanReset = false
};
_context.EmployeeLogins.Add(emp);
employee.AccountCreated = true;
_context.SaveChanges();
var vm = new LoginViewModel()
{
Email = registerVm.Email,
EmployeeNumber = registerVm.EmployeeNumber
};
Logger.LogAction("Registered", "None.", emp);
return(View("Login", vm));
}
public async Task <ActionResult> Login([FromBody] EmployeeLogin employee)
{
var res = await _employeeRepo.Login(employee.Email, employee.Password);
if (res == null)
{
return(BadRequest());
}
return(Ok(res));
}
