static void Main(string[] args)
{
DemoEntities context = new DemoEntities();
Employee e = new Employee();
Console.Write("Enter Employee Name : ");
e.EmployeeName = Console.ReadLine();
Console.Write("Enter Department : ");
e.Department = Console.ReadLine();
Console.Write("Employement Type\n1. Permanent\n2. Contract\nEnter Employment Type : ");
e.EmployeeTypeId = Convert.ToInt32(Console.ReadLine());
EmployeeManagerFactory factory = new EmployeeManagerFactory();
IEmployeeManager manager = factory.GetEmployeeManager(e.EmployeeTypeId.Value);
e.HourlyPay = manager.GetHourlyPay();
e.BonusRate = manager.GetBonusRate();
context.Employees.Add(e);
context.SaveChanges();
foreach (var emp in context.Employees)
{
Console.WriteLine("{0}, {1}, {2}, {3}, {4}, {5}, {6}", emp.EmployeeId, emp.EmployeeName, emp.Department, emp.EmployeeTypeId, emp.EmployeeType.EmployeeType1, emp.HourlyPay, emp.BonusRate);
}
}
protected void Button1_Click(object sender, EventArgs e)
{
string empName = TextBox1.Text;
DateTime dob = Convert.ToDateTime(TextBox2.Text);
string division = TextBox3.SelectedItem.ToString();
DateTime doj = Convert.ToDateTime(TextBox7.Text);
string gender = RadioButtonList1.SelectedValue;
float ctc = float.Parse(TextBox5.Text);
string designation = TextBox6.SelectedItem.ToString();
int unitheadId = Convert.ToInt32(DropDownList1.SelectedValue);
int projectId = Convert.ToInt32(DropDownList2.SelectedValue);
bool ishr = false;
bool isnew = true;
IEmployeeManager empMngr = new EmployeeManagerFactory().CreateEmployeeManager();
int row = empMngr.AddEmployee(empName, dob, doj, gender, division, ctc, designation, unitheadId, projectId, ishr, isnew);
if (row > 0)
{
IUsermanager umngr = new UserManagerFactory().CreateUserManager();
umngr.AddUser(row.ToString(), "tcshyd", Convert.ToInt32(isnew));
Response.Write("<script>alert('Added successfully - EmpID : " + row + "');window.location='Home_HR.aspx'</script>");
}
else
{
Response.Write("<script>alert('Failed')</script>");
}
}
// GET api/values
public async System.Threading.Tasks.Task <IEnumerable <EmployeeModel> > GetAsync()
{
// Method has to be refactored, implement dependency injection and move out the following logic to differnt class, so that this can be unit testable
try
{
EmployeeRepository employee = new EmployeeRepository();
var empData = await employee.GetEmployeeAsync(1);
BaseEmpFactory empFactory;
foreach (var emp in empData)
{
empFactory = new EmployeeManagerFactory().CreateFactory(emp);
empFactory.ApplySalary();
}
return(empData);
}
catch (Exception ex)
{
Console.Write(ex);
return(new List <EmployeeModel> {
});
}
}
protected void Submit_Click(object sender, EventArgs e)
{
string strempid = ddlemployees.SelectedItem.Text;
IEmployeeManager objEmployeemanager = EmployeeManagerFactory.Create_EmployeeManager();
List <IEmployee> lstEmployees = objEmployeemanager.ListOfEmployees();
foreach (IEmployee emp in lstEmployees)
{
if (emp.get_EmployeeID == Convert.ToInt32(strempid))
{
if ((objEmployeemanager.addtestadmin(Convert.ToInt32(strempid))) == 1)
{
if (emp.get_Designation == "unithead")
{
DialogResult result = MessageBox.Show("Employee with ID: " + emp.get_EmployeeID + " is added as Test Administrator succcessfully.", "Success:", MessageBoxButtons.OK);
break;
}
else
{
DialogResult result = MessageBox.Show("Employee with ID: " + emp.get_EmployeeID + " is selected as Test Administrator.\nYet to be approved by Unit Head.", "Success:", MessageBoxButtons.OK);
break;
}
}
}
}
populate_ddl();
}
public ActionResult Create([Bind(Include = "Id,Name,JobDesc,Number,Department,HourlyPay,Bonus,EmployeeTypeId")] Employee employee)
{
if (ModelState.IsValid)
{
//EmployeeManagerFactory empFactory = new EmployeeManagerFactory();
//IEmployeeManager empManager = empFactory.GetEmployeeManager(employee.EmployeeTypeId);
//if (empManager != null)
//{
// employee.Bonus = empManager.GetBonus();
// employee.HourlyPay = empManager.GetHourlyPay();
//}
BaseEmployeeFactory employeeFactory = new EmployeeManagerFactory().CreateFactory(employee);
employeeFactory.ApplySalary();
IComputerFactory computerFactory = new EmployeeSystemFactory().Create(employee);
EmployeeSystemManager manager = new EmployeeSystemManager(computerFactory);
employee.ComputerDetails = manager.GetSystemDetails();
db.Employees.Add(employee);
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.EmployeeTypeId = new SelectList(db.EmployeeTypes, "Id", "Types", employee.EmployeeTypeId);
return(View(employee));
}
static void Main(string[] args)
{
Employee employee = GetData();
BaseEmployeeFactory employeeFactory = new EmployeeManagerFactory().CreateFactory(employee);
employeeFactory.ApplySalary();
//EmployeeManagerFactory employeeManagerFactory = new EmployeeManagerFactory();
//IEmployeeManager employeeManager = employeeManagerFactory.GetEmployeeManager(employee.Type);
//employee.Bounus = employeeManager.GetBonus();
//employee.Pay = employeeManager.GetPay();
//if(employee.Type == 1)
//{
// employee.Pay = 500;
// employee.Bounus = 250;
//}
//else if (employee.Type == 2)
//{
// employee.Pay = 300;
// employee.Bounus = 100;
//}
PrintEmployee(employee);
}
static void Main(string[] args)
{
Employees employees = new Employees();
//=== Get user inputs=====
Console.WriteLine("Enter the Employee Name:- ");
string employeeName = string.Empty;
employeeName = Console.ReadLine();
Console.WriteLine("Employee Type number (1=Permanent, 2= Contractor):- ");
int employeeTypeID = Convert.ToInt32(Console.ReadLine());
employees.Name = employeeName;
employees.EmployeeTypeID = employeeTypeID;
// ====Pass data to factory====
BaseEmployeeFactory employeeManagerFactory = new EmployeeManagerFactory().CreateFectory(employees);
employeeManagerFactory.ApplySalary();
//======= Print Employee Details ======
Console.WriteLine("Employee Name:- " + employees.Name);
Console.WriteLine("Employee Bonus:- " + employees.HourlyPay);
Console.WriteLine("Employee Bonus:- " + employees.Bonus);
Console.WriteLine("Employee MedicalAllowance:- " + employees.MedicalAllowance);
Console.WriteLine("Employee HourseAllowance:- " + employees.HourseAllowance);
}
public ActionResult Create([Bind(Include = "Id,Name,JobDescription,Number,Department,HourlyPay,Bonus,EmployeeTypeID")] Employee employee)
{
if (ModelState.IsValid)
{
/*
* THIS IS AN EXAMPLE OF TIGHT COUPLING
*
* if (employee.EmployeeTypeID == 1)
* {
* employee.HourlyPay = 8;
* employee.Bonus = 10;
* }
* else if (employee.EmployeeTypeID == 2)
* {
* employee.HourlyPay = 12;
* employee.Bonus = 5;
* }
*/
EmployeeManagerFactory empFactory = new EmployeeManagerFactory();
IEmployeeManager empManager = empFactory.GetEmployeeManager(employee.EmployeeTypeID);
employee.Bonus = empManager.GetBonus();
employee.HourlyPay = empManager.GetPay();
db.Employees.Add(employee);
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.EmployeeTypeID = new SelectList(db.Employee_Type, "Id", "EmployeeType", employee.EmployeeTypeID);
return(View(employee));
}
public async Task <IActionResult> Create([Bind("Id,Name,JobDescription,Number,Department,HourlyPay,Bonus,EmployeeTypeId")] EmployeeSystemDesignPatterns.Models.EmployeeModels.Employee employee)
{
if (ModelState.IsValid)
{
//For Simple Factory
//EmployeeManagerFactory empFactory = new EmployeeManagerFactory();
//var empManager = empFactory.createFactory(employee.EmployeeTypeId);
//employee.Bonus = empManager.getBonus();
//employee.HourlyPay = empManager.getPay();
//For Factory Method Design Pattern
EmployeeManagerFactory empFactory = new EmployeeManagerFactory();
var baseEmployeeFactory = empFactory.createEmployeeTypeFactory(employee);
baseEmployeeFactory.ComputeAllowances();
//For Abstract Factory Method Pattern
EmployeeSystemFactory employeeSystemFactory = new EmployeeSystemFactory();
var createdFactory = employeeSystemFactory.Create(employee);
EmployeeSystemManager manager = new EmployeeSystemManager(createdFactory);
employee.ComputerDetails = manager.getSystemDetails();
_context.Add(employee);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
// ViewBag.EmployeeTypeID = new SelectList(_context.EmployeeTypes, "EmployeeTypesId", "EmpType", employee.EmployeeTypeId);
return(View(employee));
//return View(employee);
}
public ActionResult Create([Bind(Include = "Id,Name,JobDescription,Number,Department,HourlyPay,Bonus,EmployeeTypeID")] Employee.Web.Models.Employee employee)
{
if (ModelState.IsValid)
{
//calcaulate bonus
// businees logic inside controller -- bad practice
//if (employee.EmployeeTypeID ==1) // permanent
//{
// employee.HourlyPay = 8;
// employee.Bonus = 10;
//}
//else if (employee.EmployeeTypeID == 2)
//{
// employee.HourlyPay = 12;
// employee.Bonus = 5;
//}
BaseEmployeeFactory empFactory = new EmployeeManagerFactory().CreateFactory(employee);
//IEmployeeManager empManager = empFactory.GetEmployeeManager(employee.EmployeeTypeID);
//employee.Bonus = empManager.GetBonus();
//employee.HourlyPay = empManager.GetHourlyPay();
empFactory.ApplySalary();
db.Employees.Add(employee);
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.EmployeeTypeID = new SelectList(db.EmployeeTypes, "Id", "EmployeeType1", employee.EmployeeTypeID);
return(View(employee));
}
// GET api/values/5
public async System.Threading.Tasks.Task <IEnumerable <EmployeeModel> > GetAsync(int id)
{
try
{
// Method has to be refactored, implement dependency injection and move out the following logic to differnt class, so that this can be unit testable
EmployeeRepository employee = new EmployeeRepository();
var empData = await employee.GetEmployeeAsync(1);
var selectedEmployee = empData.FirstOrDefault((p) => p.id == id);
BaseEmpFactory empFactory;
empFactory = new EmployeeManagerFactory().CreateFactory(selectedEmployee);
empFactory.ApplySalary();
List <EmployeeModel> lstEmpModel = new List <EmployeeModel>();
lstEmpModel.Add(selectedEmployee);
return(lstEmpModel);
}
catch (Exception ex)
{
Console.Write(ex);
return(new List <EmployeeModel> {
});
}
}
public ActionResult Create([Bind(Include = "Id,Name,JobDescription,Number,Department,HourlyPay,Bonus,EmployeeTypeId")] Employee employee)
{
if (ModelState.IsValid)
{
#region SimpleFactory
//EmployeeManagerFactory empFactory = new EmployeeManagerFactory();
//IEmployeeManager empManager = empFactory.GetEmployeeManager(employee.EmployeeTypeId);
//employee.HourlyPay = empManager.GetPay();
//employee.Bonus = empManager.GetBonus();
#endregion
BaseEmployeeFactory empFactory = new EmployeeManagerFactory().CreateFactory(employee);
empFactory.ApplySalary();
//abstract factory
IComputerFactory factory = new EmployeeSystemFactory().Create(employee);
EmployeeSystemManager manager = new EmployeeSystemManager(factory);
employee.ComputerDetails = manager.GetSystemDetails();
db.Employees.Add(employee);
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.EmployeeTypeId = new SelectList(db.Employee_Type, "Id", "EmployeeType", employee.EmployeeTypeId);
return(View(employee));
}
private static void SimpleFactoryPattern_WithUsing_RIP_Pattern(int EmpType)
{
//In this case we achieved de-coupling. We actually do polymorphisim. Poly achieves decoupling.
EmployeeManagerFactory empFactory = new EmployeeManagerFactory();
IEmployeeManager emp = empFactory.GetEmployeeTypeObject_WithUsing_RIP_Pattern(EmpType);
decimal Pay = emp.GetPay();
decimal Bonus = emp.GetBonus();
}
public int SaveEmployee(Models.Employee employee)
{
EmployeeManagerFactory factory = new EmployeeManagerFactory();
IEmployeeManager manager = factory.GetManager(employee.EmployeeType.EmployeeTypeId);
employee.HourlyPay = manager.GetHourlyPay();
employee.BonusRate = manager.GetBonusRate();
return(commandRepository.SaveEmployee(employee));
}
protected void Button1_Click(object sender, EventArgs e)
{
string username = TextBox1.Text;
string password = TextBox2.Text;
IUsermanager umngr = new UserManagerFactory().CreateUserManager();
int flag = umngr.CheckUser(username, password);
IBGCAdministratorManager bmngr = new BGCAdministratorManagerFactory().CreateBGCAdministratorManager();
List <int> adminEmpIDList = bmngr.GetAdminEmpID();
if (flag.Equals(-1))
{
Label1.Text = "Invalid Login Credentials";
}
else if (flag.Equals(1))
{
Label1.Text = "New User";
Response.Redirect("LoginChange.aspx?username="******"uh"))
{
Session["unitHeadID"] = username;
Response.Redirect("Home_unitHead.aspx");
}
else if (username.StartsWith("ba"))
{
Session["adminID"] = username;
Response.Redirect("Home_admin.aspx");
}
else if (empMngr.CheckHr(Convert.ToInt32(username)).Equals(1))
{
Session["HRID"] = username;
Response.Redirect("Home_HR.aspx");
}
else
{
if (adminEmpIDList.Contains(Convert.ToInt32(username)))
{
if (bmngr.GetAdminStatus(Convert.ToInt32(username)).Equals(1))
{
Session["adminID"] = username;
Response.Redirect("Home_admin.aspx");
}
}
Session["userID"] = username;
Response.Redirect("Home_user.aspx");
}
}
}
public IActionResult Edit(int id, Employee employee)
{
var factory = new EmployeeManagerFactory();
var employeeManager = factory.GetEmployeeManager(employee.EmployeeType);
employee.Bonus = employeeManager.GetBonus();
employee.HourlyPay = employeeManager.GetPay();
_employee.UpdateEmployee(employee);
return(RedirectToAction("Index"));
}
public IActionResult Create(Employee employee)
{
var factory = new EmployeeManagerFactory();
var employeeManager = factory.GetEmployeeManager(employee.EmployeeType);
employee.Bonus = employeeManager.GetBonus();
employee.HourlyPay = employeeManager.GetPay();
var savedEmployee = _employee.AddEmployee(employee);
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Create([Bind("Id,Name,JobDescription,Number,Department,HourlyPay,Bonus,EmployeeTypeId,HouseAllowances,MedicalAllowances")] Employee employee)
{
if (ModelState.IsValid)
{
BaseEmployeeFactory baseEmployeeFactory = new EmployeeManagerFactory().CreateFactory(employee);
baseEmployeeFactory.ApplySalary();
_context.Add(employee);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["EmployeeTypeId"] = new SelectList(_context.EmployeeType, "Id", "EmployeeType1", employee.EmployeeTypeId);
return(View(employee));
}
public ActionResult Create([Bind(Include = "Id,Name,JobDescription,Number,Department,HourlyPay,Bonus,EmployeeType,HouseAllowance,MedicalAllowance")] Employee employee)
{
if (ModelState.IsValid)
{
BaseEmployeeFactory employeeFactory = new EmployeeManagerFactory().CreateFactory(employee);
employeeFactory.ApplySalary();
db.Employees.Add(employee);
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.EmployeeType = new SelectList(db.Employee_Type, "Id", "EmployeeType", employee.EmployeeType);
return(View(employee));
}
public async Task <IActionResult> New(Employee employee)
{
if (ModelState.IsValid)
{
BaseEmployeeFactory empFactory = new EmployeeManagerFactory().CreateFactory(employee);
empFactory.ApplySalary();
db.Add(employee);
await db.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["DepartmentId"] = new SelectList(db.Departments, "Id", "DepartmentName", employee.DepartmentId);
ViewData["EmployeeTypeId"] = new SelectList(db.EmployeeTypes, "Id", "EmployeeTypeName", employee.EmployeeTypeId);
return(View(employee));
}
static void Main(string[] args)
{
Console.WriteLine("-----------Employee Management System!!!---------------");
Console.Write("Please enter employee type to get 'Bonus' & 'Pay' info!-> ");
int employeeType = Convert.ToInt32(Console.ReadLine());
EmployeeManagerFactory empFactory = new EmployeeManagerFactory();
IEmployeeManager employeeManager = empFactory.GetEmployeeManager(employeeType);
var bonus = employeeManager.GetBonus();
var pay = employeeManager.GetPay();
Console.WriteLine("Get Bonus : " + bonus);
Console.WriteLine("Get Pay : " + pay);
Console.Write("Press any key to exit!!!");
Console.ReadLine();
}
public ActionResult Edit([Bind(Include = "Id,Name,JobDescription,Number,Department,HourlyPay,Bonus,EmployeeTypeID,HouseAllowance,MedicalAllowance")] Employee employee)
{
if (ModelState.IsValid)
{
BaseEmployeeFactory empFactory = new EmployeeManagerFactory().CreateFactory(employee);
empFactory.ApplySalary();
IComputerFactory factory = new EmployeeSystemFactory().Create(employee);
EmployeeSystemManager manager = new EmployeeSystemManager(factory);
employee.ComputerDetails = manager.GetSystemDetails();
db.Entry(employee).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(employee));
}
public ActionResult Create([Bind(Include = "Id,Name,JobDescription,Number,Department,HourlyPay,Bonus,EmployeeType")] Employee employee)
{
if (ModelState.IsValid)
{
EmployeeManagerFactory empFactory = new EmployeeManagerFactory();
IEmployeeManager empManager = empFactory.GetEmployeeManager(employee.EmployeeType.Value);
employee.Bonus = empManager.GetBonus();
employee.HourlyPay = empManager.GetPay();
db.Employees.Add(employee);
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.EmployeeType = new SelectList(db.Employee_Type, "Id", "EmployeeType", employee.EmployeeType);
return(View(employee));
}
public ActionResult Create([Bind(Include = "Id,Name,JobDescription,Number,Department,HourlyPay,Bonus,EmployeeTypeID")] Employee employee)
{
if (ModelState.IsValid)
{
BaseEmployeeFactory employeeManagerFactory = new EmployeeManagerFactory().CreateFactory(employee);
employeeManagerFactory.ApplySalary();
IComputerFactory factory = new EmployeeSystemFactory().Create(employee);
EmployeeSystemManager manager = new EmployeeSystemManager(factory);
employee.ComputerDetails = manager.GetSystemDetails();
db.Employee.Add(employee);
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.EmployeeTypeID = new SelectList(db.Employee_Type, "Id", "EmployeeType", employee.EmployeeTypeID);
return(View(employee));
}
public async Task <IActionResult> New(Employee employee)
{
if (ModelState.IsValid)
{
EmployeeManagerFactory employeeManagerFactory = new EmployeeManagerFactory();
IEmployeeManager manager = employeeManagerFactory.GetEmployeeManager(employee.EmployeeTypeId);
employee.Bonus = manager.GetBonus();
employee.HourlyPay = manager.GetPay();
db.Add(employee);
await db.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["DepartmentId"] = new SelectList(db.Departments, "Id", "DepartmentName", employee.DepartmentId);
ViewData["EmployeeTypeId"] = new SelectList(db.EmployeeTypes, "Id", "EmployeeTypeName", employee.EmployeeTypeId);
return(View(employee));
}
public async Task <ActionResult> Create([Bind(Include = "Id,Name,Number,DepartmentID,DesignationID,EmployeeTypeID")] Employee employee)
{
if (ModelState.IsValid)
{
BaseEmployeeFactory bEmpFact = new EmployeeManagerFactory().GetFactory(employee);
bEmpFact.CalculateSalary();
db.Employees.Add(employee);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
ViewBag.DepartmentID = new SelectList(db.Departments, "Id", "DepartmentName", employee.DepartmentID);
ViewBag.DesignationID = new SelectList(db.Designations, "Id", "DesignationName", employee.DesignationID);
ViewBag.EmployeeTypeID = new SelectList(db.EmployeeTypes, "Id", "EmployeeTypeName", employee.EmployeeTypeID);
return(View(employee));
}
public async Task <IActionResult> Create([Bind("Id,Name,JobDescription,Number,Department,HourlyPay,Bonus,EmployeeTypeId")] Employee employee)
{
if (ModelState.IsValid)
{
EmployeeManagerFactory employeeManagerFactory = new EmployeeManagerFactory();
IEmployeeManager employeeManager = employeeManagerFactory.GetEmployeeMangager(employee.EmployeeTypeId);
employee.Bonus = employeeManager.GetBonus();
employee.HourlyPay = employeeManager.GetPay();
_context.Add(employee);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["EmployeeTypeId"] = new SelectList(_context.EmployeeType, "Id", "EmployeeType1", employee.EmployeeTypeId);
return(View(employee));
}
public ActionResult Create([Bind(Include = "Id,Name,Salary,Bonus,Type,Designation")] Employee employee)
{
if (ModelState.IsValid)
{
EmployeeManagerFactory em = new EmployeeManagerFactory();
var Emp = em.GetEmployee(employee.Type);
employee.Bonus = (decimal)Emp.Bonus();
employee.Salary = (decimal)Emp.Salary();
db.Employee.Add(employee);
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.Id = new SelectList(db.Employee_Type, "Id", "Type", employee.Id);
return(View(employee));
}
private static void Main()
{
var employee = new Employee
{
EmployeeType = EmployeeType.Permanent
};
var factory = new EmployeeManagerFactory().GetEmployeeManager(employee);
factory.ApplySalary();
//
employee = new Employee
{
EmployeeType = EmployeeType.Contract
};
factory = new EmployeeManagerFactory().GetEmployeeManager(employee);
factory.ApplySalary();
}
public void TestMethodForCalculateAnnualSalary()
{
//Create test employee object
EmployeeModel selectedEmployee = new EmployeeModel();
selectedEmployee.id = 1;
selectedEmployee.hourlySalary = 80;
selectedEmployee.contractTypeName = "HourlySalaryEmployee";
BaseEmpFactory baseEmpFactory; //Instantiate factory class
baseEmpFactory = new EmployeeManagerFactory().CreateFactory(selectedEmployee);
baseEmpFactory.ApplySalary();
decimal localAnualLogic = 120 * selectedEmployee.hourlySalary * 12;
// Assert
Assert.IsNotNull(selectedEmployee);
Assert.AreEqual(localAnualLogic, actual: selectedEmployee.annualSalary);
}
