public ActionResult CreateOrEditEmployee()
{
EmployeeResponse _response = new EmployeeResponse();
if (Request.QueryString["id"] != null)
{
var request = new EmployeeRequest
{
Data = new EmployeeModel
{
Id = long.Parse(Request.QueryString["id"].ToString())
}
};
EmployeeResponse resp = new EmployeeHandler(_unitOfWork).GetDetail(request);
EmployeeModel _model = resp.Entity;
ViewBag.Response = _response;
ViewBag.EmpTypes = BindDropDownEmployementType();
ViewBag.EmplStatus = BindDropDownEmployeeStatus();
ViewBag.EmpActive = BindDropDownEmployeeReff();
ViewBag.ActionType = ClinicEnums.Action.Edit;
return(View(_model));
}
else
{
ViewBag.ActionType = ClinicEnums.Action.Add;
ViewBag.Response = _response;
ViewBag.EmpTypes = BindDropDownEmployementType();
ViewBag.EmplStatus = BindDropDownEmployeeStatus();
ViewBag.EmpActive = BindDropDownEmployeeReff();
return(View());
}
}
public bool checkAuthority(string role)
{
EmployeeHandler eh = new EmployeeHandler();
SqlDataReader sdr = eh.findEmployeelimits(role);
string limits = "";
if (sdr.Read())
{
limits = sdr["limits"].ToString();
}
if (limits.Length > 0)
{
string[] arrLimits = limits.Split('、');
for (int i = 0; i < arrLimits.Length; i++)
{
string limitsName = arrLimits[i];
if ("发药显示".Equals(limitsName))
{
return(true);
}
}
}
return(false);
}
static void Main(string[] args)
{
bool isValid = true;
while (isValid)
{
UiOperations.OpeningOptions();
if (ReadKeyFromUser(out var keyOptions, out isValid))
{
break;
}
var helper = new EmployeeHandler(_repository);
UiOperations.SubscribingToKeyEvents(keyOptions, helper);
try
{
keyOptions.RespondingToKeyEvents();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
}
public async Task Update_ModifyEmployeeBySingleUser_ReturnsTrue()
{
var handler = new EmployeeHandler();
Employee employee = new Employee()
{
Name = "Alaa Al Saadi -Test - ",
Email = $"Alaa@{Guid.NewGuid()}",
Gender = Gender.Male,
Status = Status.Active
};
var orginalEmployee = await handler.CreateAsync(employee);
var modifiedEmployee = new Employee()
{
Id = orginalEmployee.Id,
Name = $"{orginalEmployee.Name} [Update_ModifyEmployee_ReturnsTrue]",
Email = orginalEmployee.Email,
Gender = Gender.Female,
Status = Status.Inactive
};
var result = await handler.UpdateAsync(modifiedEmployee, orginalEmployee);
Assert.IsTrue(result);
}
public async Task Update_ModifyEmployeeConcurrently_ThrowsDataConcurrencyException()
{
var handler = new EmployeeHandler();
Employee employee = new Employee()
{
Name = "Alaa Al Saadi -Test - [Update_ModifyEmployeeByMultiUserConcurrently_ThrowDataConcurrencyException]",
Email = $"Alaa@{Guid.NewGuid()}",
Gender = Gender.Male,
Status = Status.Active
};
var orginalEmployee = await handler.CreateAsync(employee);
var modifiedEmployee = new Employee()
{
Id = orginalEmployee.Id,
Name = $"{orginalEmployee.Name} DataConcurrencyException",
Email = orginalEmployee.Email,
Gender = Gender.Female,
Status = Status.Inactive
};
orginalEmployee.UpdateTime = DateTime.Now.AddMinutes(-1);
await handler.UpdateAsync(modifiedEmployee, orginalEmployee);
}
protected void Page_Load(object sender, EventArgs e)
{
string id = Request.QueryString["id"] as string;
if (id == null)
{
Response.Redirect("Default.aspx");
}
try
{
empID = Convert.ToInt32(id.Trim());
empHandler = new EmployeeHandler();
Employee emp = empHandler.GetEmployeeDetails(empID);
lblEmployeeID.Text = emp.EmployeeID.ToString();
lblLastName.Text = emp.LastName;
lblFirstName.Text = emp.FirstName;
lblTitle.Text = emp.Title;
lblAddress.Text = emp.Address;
lblCity.Text = emp.City;
lblCountry.Text = emp.Country;
lblRegion.Text = emp.Region;
lblPostalCode.Text = emp.PostalCode;
lblExtension.Text = emp.Extension;
}
catch (Exception)
{
Response.Redirect("Default.aspx");
}
}
public async Task ReadPage_GetByPageNumber_ReturnsListOfEmployees()
{
var handler = new EmployeeHandler();
var list = await handler.ReadPageAsync(2);
Assert.IsTrue(list.Count() > 0 && handler.Pager.CurrentPage == 2);
}
public ActionResult Index()
{
var handler = new EmployeeHandler();
List <Employee> employeeList = handler.GetEmployees();
return(View(employeeList));
}
public AddEmployeeDialog()
{
InitializeComponent();
AccessModeComboBox.ItemsSource = Enum.GetNames(typeof(AccessMode));
_employeeHandler = new EmployeeHandler();
_securityHandler = new SecurityHandler();
}
public void TestGetEmployeesReturnTwoEmployees()
{
EmployeeHandler _sut = EmployeeHandler.Instance;
var employees = _sut.GetEmployees();
Assert.AreEqual(2, employees.Count);
}
public ActionResult GetEmployee()
{
var _draw = Request.Form.GetValues("draw").FirstOrDefault();
var _start = Request.Form.GetValues("start").FirstOrDefault();
var _length = Request.Form.GetValues("length").FirstOrDefault();
var _sortColumn = Request.Form.GetValues("columns[" + Request.Form.GetValues("order[0][column]").FirstOrDefault() + "][name]").FirstOrDefault();
var _sortColumnDir = Request.Form.GetValues("order[0][dir]").FirstOrDefault();
var _searchValue = Request.Form.GetValues("search[value]").FirstOrDefault();
int _pageSize = _length != null?Convert.ToInt32(_length) : 0;
int _skip = _start != null?Convert.ToInt32(_start) : 0;
var request = new EmployeeRequest
{
Draw = _draw,
SearchValue = _searchValue,
SortColumn = _sortColumn,
SortColumnDir = _sortColumnDir,
PageSize = _pageSize,
Skip = _skip
};
var response = new EmployeeHandler(_unitOfWork).GetListData(request);
return(Json(new { data = response.Data, recordsFiltered = response.RecordsFiltered, recordsTotal = response.RecordsTotal, draw = response.Draw }, JsonRequestBehavior.AllowGet));
}
public void BeforeTest()
{
MainViewModel.OpenDbConnection = false;
Assert.IsFalse(MainViewModel.OpenDbConnection); //Making sure that the Database API connection is closed during unit testing.
_mainViewModel = new MainViewModel();
_employeeHandler = new EmployeeHandler(_mainViewModel);
_testEmployee = new StandardEmp()
{
EmployeeId = 22, Name = "TestEmployee", SickDays = 0, VacationDays = 0, Manager = "NotAdminTestEmployee", SalaryNumber = 1
};
_testEmployee2 = new StandardEmp()
{
EmployeeId = 50, Name = "TestEmployee2"
};
_testAdminEmp = new AdminEmp()
{
EmployeeId = 75, Name = "AdminTestEmployee", AdminLvl = 1
};
_testAdminEmp2 = new AdminEmp()
{
EmployeeId = 15, AdminLvl = 2, Name = "AdminLvl2TestEmployee"
};
_mainViewModel.EmployeesInDb.Add(_testEmployee);
_mainViewModel.EmployeesInDb.Add(_testEmployee2);
_mainViewModel.EmployeesInDb.Add(_testAdminEmp);
_mainViewModel.EmployeesInDb.Add(_testAdminEmp2);
_mainViewModel.LoggedInEmployees.Add(_testEmployee2);
}
public void TestHrDbReturnSameInstance()
{
EmployeeHandler _sut = EmployeeHandler.Instance;
EmployeeHandler actual = new EmployeeHandler();
object.ReferenceEquals(_sut, actual);
}
public EmployeePaymentWindow()
{
_employeeHandler = new EmployeeHandler();
_employeePaymentHandler = new EmployeePaymentHandler();
EmployeeSource = _employeeHandler.GetEmployees();
InitializeComponent();
}
public MainViewModel()
{
EmployeeHandler = new EmployeeHandler(this);
if (OpenDbConnection)
{
PersistencyService.OpenApiConnection();
}
EmployeesInDb = new ObservableCollection <Employee>();
LoggedInEmployees = new List <Employee>();
DatabaseTable = new ObservableCollection <Employee>();
if (OpenDbConnection)
{
PersistencyService.GetData(EmployeesInDb);
PersistencyService.GetDataLoggedIn(LoggedInEmployees);
}
LoginOrLogoutCommand = new RelayCommand(EmployeeHandler.LoginOrLogout);
CompleteEmployeeListCommand = new RelayCommand(EmployeeHandler.CompleteEmployeeList);
PersonalEntryListCommand = new RelayCommand(EmployeeHandler.PersonalEntryList);
OwnDepartmentListCommand = new RelayCommand(EmployeeHandler.OwnDepartmentList);
AddSickOrVacationdaysCommand = new RelayCommand(EmployeeHandler.ChangeVacationOrSickdays);
AdminChangePersonalInfoCommand = new RelayCommand(EmployeeHandler.AdminChangePersonalInfo);
AdminChangeSalaryInfoCommand = new RelayCommand(EmployeeHandler.AdminChangeSalaryInfo);
SortByNameCommand = new RelayCommand(EmployeeHandler.SortByName);
SortByEmployeeIdCommand = new RelayCommand(EmployeeHandler.SortByEmployeeId);
ExportAsCsvCommand = new RelayCommand(() => ExportEmployeesToCsvFile());
}
public void TestDeleteSubjectFromEmployeeReturnOne()
{
EmployeeHandler _sut = EmployeeHandler.Instance;
int expected = 1;
int actual = _sut.DeleteSubjectFromEmployee(1, 2);
Assert.AreEqual(expected, actual);
}
public void TestCloseEmployeeReturnOne()
{
EmployeeHandler _sut = EmployeeHandler.Instance;
int expected = 1;
int actual = _sut.CloseEmployee(1);
Assert.AreEqual(expected, actual);
}
public ProjectsController()
{
_Context = new SREDContext();
_EmployeeRepository = new EmployeeRepository(_Context);
_ProjectRepository = new ProjectRepository(_Context);
_SREDCategoryRepository = new SREDCategoryRepository(_Context);
_EmployeeHandler = new EmployeeHandler(_Context, _EmployeeRepository);
}
public ActionResult Edit(ProfileModel model)
{
var profile = ProfileModelIMapper.Maptoprofile(model);
EmployeeHandler.Update(profile);
return(RedirectToAction("Index"));
// return View("Index", model);
}
public void TestAddSubjectToEmployeeReturnOne()
{
EmployeeHandler _sut = EmployeeHandler.Instance;
int expected = 1;
int actual = _sut.AddSubjectToEmployee(2, 3);
Assert.AreEqual(expected, actual);
}
public ViewResult Edit()
{
var user = (User)Session[Constants.LoggedInUserName];
var profile = EmployeeHandler.GetEmployee(user.EmployeeID);
var profileModel = ProfileModelIMapper.MapToProfileModel(profile);
return(View(profileModel));
}
public ActionResult Edit(int id = 0)
{
var employee = EmployeeHandler.GetEmployee(id);
var employeeModel = EmployeeModelMapper.MapToEmployeeModel(employee);
return(View(employeeModel));
}
public void TestGetEmployeesReturnListOfEmployees()
{
EmployeeHandler _sut = EmployeeHandler.Instance;
var employees = _sut.GetEmployees();
Type actual = employees[0].GetType();
Type expected = typeof(EmployeeM);
Assert.AreEqual(expected, actual);
}
protected void Page_Load(object sender, EventArgs e)
{
lblResult.Text = string.Empty;
emphandler = new EmployeeHandler();
if (!IsPostBack)
{
BindData();
}
}
public StaffController()
{
_Context = new SREDContext();
_EmployeeRepository = new EmployeeRepository(_Context);
_EmployeeHandler = new EmployeeHandler(_Context, _EmployeeRepository);
_projectEntryHandler = new ProjectEntryHandler(_Context, _projectEntryRepository);
_staffView = new StaffView();
_fakeEmployee = new FakeEmployee();
}
public void TestUpdateEmployeeReturnOne()
{
EmployeeHandler _sut = EmployeeHandler.Instance;
int expected = 1;
int actual = _sut.UpdateEmployee(2, "Karine", "Olsen", "Florasvej 1",
6000, "*****@*****.**", "22222222",
"Advokat", 1000);
Assert.AreEqual(expected, actual);
}
public void TestNewEmployeeReturnOne()
{
EmployeeHandler _sut = EmployeeHandler.Instance;
int expected = 1;
int actual = _sut.NewEmployee("1234567890", "Karin", "Olsen", "Florasvej 1",
6000, "*****@*****.**", "22222222",
DateTime.Now, "Advokat", 750);
Assert.AreEqual(expected, actual);
}
// Creates a new employee user
public ActionResult CreateEmployee()
{
// Ensures logged in
if (Session["loggedInState"] == null)
{
return(Redirect("/403.html"));
}
// Checks if logged in
bool state = (bool)Session["loggedInState"];
if (state == true)
{
// Establishes models
LoginModel eModel = new LoginModel();
// Stored details for the employee
String firstname = Request.Form["firstname"];
String surname = Request.Form["lastname"];
DateTime DOB = DateTime.Parse(Request.Form["DOB"]);
String contactNum = Request.Form["contactNum"];
DateTime startDate = DateTime.Parse(Request.Form["startDate"]);
int dept = int.Parse(Request.Form["dept"]);
int depot = int.Parse(Request.Form["depot"]);
int role = int.Parse(Request.Form["role"]);
// Stored details for the user
String username = Request.Form["username"];
String password = Request.Form["password"];
String email = Request.Form["email"];
// Establishes handlers
EmployeeHandler emHandler = new EmployeeHandler();
// Creates employee for user
int employeeID = emHandler.create(firstname, surname, DOB, contactNum, startDate, dept, depot, role);
// Holds new object
User newUser = new User();
// Creates user details
newUser.username = username;
newUser.password = password;
newUser.email = email;
// Return created department to view
return(View(newUser));
}
else
{
// If not logged in
return(Redirect("/login.html"));
}
}
public ActionResult Index(string from, string to, string pageSize, int page = 1)
{
//handle hours
DateTime now = DateTime.Now;
DateTime weekStart = now.AddDays(-(int)now.DayOfWeek);
DateTime fromDate = ((from == null) || (from == "")) ? weekStart : Convert.ToDateTime(from);
DateTime toDate = ((to == null) || (to == "")) ? weekStart.AddDays(6) : Convert.ToDateTime(to);
var budget = EmployeeHandler.totalHours(fromDate, toDate) *
_EmployeeHandler.all().LongCount();
var hours = _EmployeeHandler.hours(fromDate, toDate);
// Disable Google OAuth
// var user = _EmployeeHandler.HandleGetEmployee((ClaimsIdentity)User.Identity);
// Only check for user in session for demo.
Employee user = (Employee)Session["User"];
;
ViewData["User"] = user.FirstName + " " + user.LastName;
//insert values into model
_staffView.budget = budget;
_staffView.hours = hours;
_staffView.remaining = budget - hours;
_staffView.from = fromDate;
_staffView.to = toDate;
_staffView.fromString = fromDate.ToString(@"MM\/dd\/yyyy");
_staffView.toString = toDate.ToString(@"MM\/dd\/yyyy");
_staffView.email = user.Email;
_staffView.now = now;
var staff = _EmployeeHandler.all().ToList();
//handle pagination
int changeSize = 0;
bool isNum = Int32.TryParse(pageSize, out changeSize);
int size = 20; //default no. of employees per page
if (isNum && changeSize > 0)
{
size = changeSize;
}
_staffView.pageSize = size.ToString();
_staffView.list = new PagedList <Employee>(staff, page, size);
_staffView.ListOfPositions = _Context.Positions.Select(p => new SelectListItem
{
Value = p.PositionID.ToString(), Text = p.PositionName
});
return(View(_staffView));
}
public ActionResult Delete(int id = 0)
{
try
{
EmployeeHandler.Delete(id);
}
catch (Exception)
{
return(View("Error"));
}
return(RedirectToAction("Index"));
}
public void Count_CountFilteredEmployees_CountEmployee()
{
// Arrange
var employees = new List<Employee> { new Employee { Id = 1 }, new Employee { Id = 2 } };
var mockRepository = new Mock<IRepository>();
mockRepository.Setup(i => i.Get(It.IsAny<Expression<Func<Employee, bool>>>())).Returns(employees.AsQueryable());
var handler = new EmployeeHandler(mockRepository.Object);
// Act
var amount = handler.Count(new EmployeeQuery());
// Assert
Assert.AreEqual(employees.Count, amount);
}
public void Create_AddNewEmployee_AddEmployee()
{
// Arrange
Employee employeeAdded = null;
var mockRepository = new Mock<IRepository>();
mockRepository.Setup(i => i.Add(It.IsAny<Employee>())).Callback<Employee>(i => employeeAdded = i);
var handler = new EmployeeHandler(mockRepository.Object);
var employeeDto = new EmployeeDto { Id = 1 };
// Act
handler.Create(employeeDto);
// Assert
Assert.AreEqual(employeeDto.Id, employeeAdded.Id);
}
public void Delete_DeleteEmployee_DeleteOneEmployee()
{
// Arrange
var employees = new List<Employee> { new Employee { Id = 1 } };
var mockRepository = new Mock<IRepository>();
mockRepository.Setup(i => i.Get<Employee>(It.IsAny<int>())).Returns(employees.First(x => x.Id == 1));
mockRepository.Setup(i => i.Delete(It.IsAny<Employee>())).Callback<Employee>(i => employees.Remove(i));
var handler = new EmployeeHandler(mockRepository.Object);
var employeeDto = new EmployeeDto { Id = 1 };
// Act
handler.Delete(employeeDto.Id);
// Assert
Assert.IsEmpty(employees);
}
public void Get_GetAllEmployees_ReturnEmployees()
{
// Arrange
var mockRepository = new Mock<IRepository>();
mockRepository.Setup(i => i.Get<Employee>()).Returns((new List<Employee> { new Employee { Id = 1 }, new Employee { Id = 2 } }).AsQueryable());
var handler = new EmployeeHandler(mockRepository.Object);
// Act
var employeesDto = handler.Get();
// Assert
Assert.AreEqual(2, employeesDto.Last().Id);
}
public void Get_GetOneEmployeeById_ReturnEmployee()
{
// Arrange
var mockRepository = new Mock<IRepository>();
mockRepository.Setup(i => i.Get<Employee>(It.IsAny<int>())).Returns(new Employee { Id = 100 });
var handler = new EmployeeHandler(mockRepository.Object);
// Act
var employeeDto = handler.Get(1);
// Assert
Assert.AreEqual(100, employeeDto.Id);
}
public void Update_UpdateEmployee_UpdateEmployee()
{
// Arrange
var employee = new Employee { Name = "Test name" };
var mockRepository = new Mock<IRepository>();
mockRepository.Setup(i => i.Get<Employee>(It.IsAny<int>())).Returns(employee);
var handler = new EmployeeHandler(mockRepository.Object);
var employeeDto = new EmployeeDto { Name = "Test neme new" };
// Act
handler.Update(employeeDto);
// Assert
Assert.AreEqual(employeeDto.Name, employee.Name);
}
public void GenerateReport_GetReport_GenerateReport()
{
// Arrange
var mockRepository = new Mock<IRepository>();
mockRepository.Setup(i => i.Get(It.IsAny<Expression<Func<Employee, bool>>>()))
.Returns((new List<Employee> { new Employee { Name = "Test name" } }).AsQueryable());
var handler = new EmployeeHandler(mockRepository.Object);
// Act
var bytes = handler.GenerateReport();
var str = Encoding.Unicode.GetString(bytes);
// Assert
Assert.IsTrue(str.Contains("Test name"));
}
public void Get_GetFilteredEmployees_ReturnEmployees()
{
// Arrange
var mockRepository = new Mock<IRepository>();
mockRepository.Setup(i => i.Get(It.IsAny<Expression<Func<Employee, bool>>>()))
.Returns((new List<Employee> { new Employee { Id = 1 }, new Employee { Id = 2 } }).AsQueryable());
var handler = new EmployeeHandler(mockRepository.Object);
// Act
var employeesDto = handler.Get(new EmployeeQuery { Skip = 1, Take = 1 });
// Assert
Assert.AreEqual(2, employeesDto.First().Id);
}
