public List <EmployeeDataModel> GetAllEmployeeData()
{
List <EmployeeDataModel> employeeDataModels = new List <EmployeeDataModel>();
SqlConnection connection = new SqlConnection(LscConstant.ConnectionString);
{
connection.Open();
SqlDataAdapter daAuthors = new SqlDataAdapter("Select * from [dbo].[tblSaggezian]", connection);
DataSet dataSet = new DataSet();
daAuthors.Fill(dataSet);
DataTable tblSaggezian;
tblSaggezian = dataSet.Tables[0];
foreach (DataRow drCurrent in tblSaggezian.Rows)
{
EmployeeDataModel mode = new EmployeeDataModel();
mode.Age = Convert.ToInt32(drCurrent["Age"]);
mode.Designation = (drCurrent["Designation"]).ToString();
mode.Name = (drCurrent["Name"]).ToString();
employeeDataModels.Add(mode);
}
connection.Close();
}
return(employeeDataModels);
}
public ActionResult Calculate(EmployeeDataModel model)
{
if (!ModelState.IsValid)
{
return(View("Index", model));
}
var employeeData = new EmployeeData(model.Employee.FirstName, model.Employee.LastName);
if (model.Dependents != null && model.Dependents.Count > 0)
{
var dependents = new List <Person>();
foreach (var dependent in model.Dependents)
{
var employeeDependent = new Person(dependent.FirstName, dependent.LastName);
dependents.Add(employeeDependent);
}
employeeData.Dependents = dependents;
}
var response = BenefitsService.Value.GetEmployeeCost(employeeData);
return(View("View", response));
}
public void TestEmployeeService_Update_IfId_Lt_Zero_ThrowError(int id, string firstName)
{
/// Set up
var employeeDataModel = new EmployeeDataModel()
{
Id = id,
FirstName = firstName
};
var employee = new Employee
{
Id = id,
FirstName = firstName
};
var mapper = new Mock <IMapper>();
var employeeRepository = new Mock <IEmployeeRepository>();
employeeRepository.Setup(x => x.Add(employeeDataModel))
.Returns(id);
mapper.Setup(x => x.Map <EmployeeDataModel, Employee>(employeeDataModel))
.Returns(employee);
mapper.Setup(x => x.Map <Employee, EmployeeDataModel>(employee))
.Returns(employeeDataModel);
var employeeService = GetEmployeeServiceInstance(employeeRepository.Object, mapper.Object);
Assert.Throws <Exception>(() => employeeService.Update(employee));
}
public void TestEmployeeService_Get_ReturnsValidEmployee(int id, string firstName)
{
/// Set up
var employeeDataModel = new EmployeeDataModel();
var employee = new Employee
{
Id = id,
FirstName = firstName
};
var mapper = new Mock <IMapper>();
var employeeRepository = new Mock <IEmployeeRepository>();
employeeRepository.Setup(x => x.Get(id))
.Returns(employeeDataModel);
mapper.Setup(x => x.Map <EmployeeDataModel, Employee>(employeeDataModel))
.Returns(employee);
var employeeService = GetEmployeeServiceInstance(employeeRepository.Object, mapper.Object);
var result = employeeService.Get(id);
Assert.NotNull(result);
Assert.IsType <Employee>(result);
Assert.Equal(employee, result);
}
public IActionResult LoginEmployee(LoginEmployeeModel login)
{
if (ModelState.IsValid)
{
EmployeeDataModel employeeData = EmployeeProcessor.GetUserByEmail(login.Email);
if (employeeData != null)
{
if (PasswordHashingLogic.ValidateUser(login.Password, employeeData.Salt, employeeData.PasswordHash))
{
var employeeClaims = new List <Claim>()
{
new Claim(ClaimTypes.Email, employeeData.Email),
new Claim(ClaimTypes.Role, employeeData.Role)
};
var employeeIdentity = new ClaimsIdentity(employeeClaims, "Employee Identity");
var employeePrincipal = new ClaimsPrincipal(new[] { employeeIdentity });
HttpContext.SignInAsync(employeePrincipal);
return(RedirectToAction("Dashboard", "Home"));
}
}
else
{
ModelState.AddModelError("incorrectLogin", "The provided email and password do not match.");
}
}
return(View());
}
public static void CreateEmployee(string firstname, string prefix, string lastname, string city, string postalCode,
string address, string profilePicturePath, string email, string phone, string salt,
string password, string profession, string role)
{
EmployeeDataModel data = new EmployeeDataModel
{
Firstname = firstname,
Lastnameprefix = prefix,
Lastname = lastname,
City = city,
PostalCode = postalCode,
Address = address,
ProfilePicturePath = profilePicturePath,
Email = email,
Phone = phone,
Salt = salt,
PasswordHash = password,
Profession = profession,
Role = role
};
string sql = @"INSERT INTO employee (firstname, lastnamePrefix, lastname, city, postalCode, address, profilePicturePath, email, phone,
salt, passwordHash, profession, role)
VALUES(@Firstname, @Lastnameprefix, @Lastname, @City, @PostalCode, @Address, @ProfilePicturePath, @Email,
@Phone ,@Salt ,@PasswordHash ,@Profession ,@Role);";
SQLDataAccess.SaveData(sql, data);
}
public Employee(EmployeeDataModel dataModel)
{
Name = dataModel.Name;
WarehouseId = dataModel.WarehouseId;
role = MapDatabaseRoleToApiRole(dataModel.Role);
ext = dataModel.Ext;
}
// GET: Employee/Edit/5
public ActionResult Edit(int id)
{
using (EmployeeDataModel context = new EmployeeDataModel())
{
var employee = context.Employees.Single(m => m.ID == id);
return(View(employee));
}
}
public ActionResult Details(int id)
{
using (EmployeeDataModel context = new EmployeeDataModel())
{
var employee = context.Employees.SingleOrDefault(e => e.ID == id);
TempData["EmployeeDetails"] = employee.Name + ", " + employee.Age;
return(View(employee));
}
}
private EmployeeViewModel PopulateEmployeeViewModel(EmployeeDataModel model)
{
return(new EmployeeViewModel()
{
EmployeeId = model.EmployeeId,
FirstName = model.FirstName,
LastName = model.LastName,
IsActive = model.IsActive
});
}
public ActionResult Create([Bind] EmployeeDataModel employee)
{
if (ModelState.IsValid)
{
objemployee.AddEmployee(employee);
return(RedirectToAction("Index"));
}
return(View(employee));
}
public async Task <EmployeeDataModel> GetEmployee(int employeeId)
{
Employee employee = await _context.Employees.SingleOrDefaultAsync(o => o.EmployeeId == employeeId);
MapperConfiguration config = new MapperConfiguration(mc => mc.CreateMap <Employee, EmployeeDataModel>());
Mapper mapper = new Mapper(config);
EmployeeDataModel resource = mapper.Map <Employee, EmployeeDataModel>(employee);
return(resource);
}
public bool AddEmployee(EmployeeDataModel employee)
{
bool status = false;
if (ModelState.IsValid)
{
status = _employeeData.AddEmployee(employee);
return(status);
}
return(status);
}
// GET: Employee
public ActionResult Index()
{
using (EmployeeDataModel context = new EmployeeDataModel())
{
List <Employee> employess = context.Employees.ToList();
//var employees = from e in context.Employees
// orderby e.ID
// select e;
return(View(employess));
}
}
public void AddEmployee_ModelInvalid_ReturnsFalse()
{
//Arrange
var employee = new EmployeeDataModel();
_employeeController.ModelState.AddModelError("error", "error");
//Act
var result = _employeeController.AddEmployee(employee);
//Assert
Assert.IsFalse(result);
}
public void AddEmployees(IEnumerable <Employee> employees)
{
string sql = "INSERT INTO em (name, w_id, role, ext) VALUES(@name, @w_id, @role, @ext)";
var parametersList = new List <NpgsqlParameter[]>();
foreach (var employee in employees)
{
var employeeDataModel = new EmployeeDataModel(employee);
parametersList.Add(employeeDataModel.GetNpgsqlParameters().ToArray());
}
RunTransaction(sql, parametersList);
}
public void AddEmployee_ModelValid_ReturnsTrue()
{
//Arrange
var employee = new EmployeeDataModel {
employeeName = "geeta", Age = 21, salaryInLakh = 3.7
};
//Act
var result = _employeeController.AddEmployee(employee);
//Assert
Assert.IsTrue(result);
}
public ActionResult Edit(int id, [Bind] EmployeeDataModel employee)
{
if (id != employee.EmployeelD)
{
return(null);
}
if (ModelState.IsValid)
{
objemployee.UpdateEmployee(employee);
return(RedirectToAction("Index"));
}
return(View(employee));
}
public ActionResult Edit(int?id)
{
if (id == null)
{
return(null);
}
EmployeeDataModel employee = objemployee.GetEmployeeData(id);
if (employee == null)
{
return(null);
}
return(View(employee));
}
public static EmployeeModel GetCurrentEmployeeModel(this HttpContext httpContext)
{
Claim email = httpContext.User.Claims.FirstOrDefault(c => c.Type == ClaimTypes.Email);
if (email == null)
{
return(null);
}
EmployeeDataModel dataModel = EmployeeProcessor.GetUserByEmail(email.Value);
EmployeeModel employeeModel = new EmployeeModel();
employeeModel.MapDataModel(dataModel);
return(employeeModel);
}
public EmployeeDataModel GetEmployeeById(int employeeId)
{
if (employeeId == 56)
{
return(null);
}
else
{
EmployeeDataModel employee = new EmployeeDataModel();
employee.employeeName = "sana";
employee.Age = 45;
employee.salaryInLakh = 9.78;
return(employee);
}
}
public static void MapDataModel(this EmployeeModel employeeModel, EmployeeDataModel dataModel)
{
employeeModel.Id = dataModel.ID;
employeeModel.Firstname = dataModel.Firstname;
employeeModel.Prefix = dataModel.Lastnameprefix;
employeeModel.Lastname = dataModel.Lastname;
employeeModel.City = dataModel.City;
employeeModel.Postalcode = dataModel.PostalCode;
employeeModel.Address = dataModel.Address;
employeeModel.ProfilePicturePath = dataModel.ProfilePicturePath;
employeeModel.Email = dataModel.Email;
employeeModel.Phone = dataModel.Phone;
employeeModel.Profession = dataModel.Profession;
employeeModel.Role = dataModel.Role.ToEnum <EmployeeRole>();
}
public EmployeeDataModel CreateEmployee([FromForm] EmployeeDataModel employee)
{
var model = new EmployeeDataModel();
model.Id = Guid.NewGuid().ToString();
model.Name = employee.Name;
model.IdentityNumber = employee.IdentityNumber;
model.Salary = employee.Salary;
model.Title = employee.Title;
model.DepartmentId = employee.DepartmentId;
_context.Employees.Add(model);
_context.SaveChanges();
return(model);
}
public ActionResult Create(Employee emp)
{
try
{
using (EmployeeDataModel context = new EmployeeDataModel())
{
context.Employees.Add(emp);
context.SaveChanges();
}
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public void SaveAllEmployeeData(EmployeeDataModel employeeDataModel)
{
SqlConnection conn = new SqlConnection(LscConstant.ConnectionString);
{
SqlCommand cmd = new SqlCommand("exec [dbo].[InsertData] @Name, @Designation, @Age", conn);
{
cmd.Parameters.AddWithValue("@Name", employeeDataModel.Name);
cmd.Parameters.AddWithValue("@Designation", employeeDataModel.Designation);
cmd.Parameters.AddWithValue("@Age", employeeDataModel.Age);
conn.Open();
cmd.ExecuteNonQuery();
conn.Close();
}
}
}
public bool AddEmployee(EmployeeDataModel _Employee)
{
var data = entityMapper.DBModelMappingPost(_Employee);
bool status;
try
{
employeeEntity.tbl_Employee.Add(data);
employeeEntity.SaveChanges();
status = true;
}
catch (Exception)
{
status = false;
}
return(status);
}
// Check View Bag and View Data
public ViewResult EmployeeNames()
{
using (EmployeeDataModel context = new EmployeeDataModel())
{
List <Employee> employess = context.Employees.ToList();
//var employees = from e in context.Employees
// orderby e.ID
// select e;
List <string> employessNames = employess.Select(x => x.Name).ToList();
// ViewBag.EmployeeNames = employessNames;
ViewData["EmployeeNames"] = employessNames;
return(View());
}
}
public async Task <int> Create(EmployeeDataModel employee)
{
using (IDbConnection db = new SqlConnection(connectionStrings.ConnBenefitsPac))
{
DynamicParameters parameters = new DynamicParameters();
parameters.Add("@EmployeeName", employee.EmployeeName);
parameters.Add("@DiscountAmount", employee.BenefitCost.DiscountAmount);
parameters.Add("@BaseDeductionCost", employee.BenefitCost.BaseDeductionCost);
parameters.Add("@PaymentFrequency", employee.EmployeeSalaryData.PaymentFrequency);
parameters.Add("@SalaryByPayPeriod", employee.EmployeeSalaryData.SalaryByPayPeriod);
parameters.Add("@RESULT", dbType: DbType.Int32, direction: ParameterDirection.ReturnValue);
await db.ExecuteAsync("CreateEmployee",
parameters,
commandType : CommandType.StoredProcedure);
return(parameters.Get <int>("@RESULT"));
}
}
public async Task <EmployeeDataModel> AddEmployee(AddEmployeeDataModel employee)
{
MapperConfiguration config = new MapperConfiguration(mc => mc.CreateMap <AddEmployeeDataModel, Employee>());
Mapper mapper = new Mapper(config);
Employee newEmployee = mapper.Map <AddEmployeeDataModel, Employee>(employee);
var phoneNumber = newEmployee.PhoneNumber;
var _ = await _context.Employees.AddAsync(newEmployee);
var __ = await _context.SaveChangesAsync();
//EmployeeDataModel
MapperConfiguration config_1 = new MapperConfiguration(mc => mc.CreateMap <Employee, EmployeeDataModel>());
Mapper mapper_1 = new Mapper(config_1);
EmployeeDataModel resource = mapper_1.Map <Employee, EmployeeDataModel>(newEmployee);
return(resource);
}
public async Task <EmployeeModel> GetById(int id)
{
try
{
if (id > 0)
{
EmployeeDataModel employeeDataModel = await employeeRepository.GetById(id);
return(new EmployeeModel(employeeDataModel));
}
return(null);
}
catch (Exception ex)
{
await loggerRepository.Log(ex).ConfigureAwait(false);
throw;
}
}