public async Task <IEnumerable <Employee> > GetByIdAsync(int id)
{
var employees = await _employeeRepository.GetAllAsync();
return(employees.Where((employee) => employee.Id == id).Select(employee =>
{
employee.AnnualSalary = SalaryFactory.GetSalary(employee).AnnualSalary();
return employee;
}));
}
public async Task <IEnumerable <Employee> > GetAllAsync()
{
var employees = await _employeeRepository.GetAllAsync();
return(employees.Select(employee =>
{
employee.AnnualSalary = SalaryFactory.GetSalary(employee).AnnualSalary();
return employee;
}));
}
public void AnnualSalaryHourlyTest()
{
double hourlySalary = 10;
double MonthlySalary = 50;
double annualSalaryExpected = 14400;
ISalaryFactory salaryFactoryObject = SalaryFactory.SalaryFactoryCreator(EContractType.HourlySalaryEmployee, hourlySalary, MonthlySalary);
double annualSalaryActual = salaryFactoryObject.GetAnnualSalary();
Assert.AreEqual(annualSalaryExpected, annualSalaryActual, 0.001, "Annual salary is incorrect");
}
public async Task <List <EmployeeModel> > GetAllEmployees <T>()
{
List <EmployeeModel> employees = await _employeeClient.GetEmployees <EmployeeModel>();
if (employees.Count() > default(int))
{
foreach (var item in employees)
{
ISalaryFactory salaryFactoryObject = SalaryFactory.SalaryFactoryCreator((EContractType)Enum.Parse(typeof(EContractType), item.ContractTypeName, true), item.HourlySalary, item.MonthlySalary);
item.AnnualSalary = salaryFactoryObject.GetAnnualSalary();
}
}
return(employees);
}
public void MonthlySalaryTest()
{
var valor = 20;
var original = valor * 12;
var n = new SalaryFactory();
var e = new Employee()
{
MonthlySalary = valor,
ContractTypeName = Enums.ContractType.MonthlySalaryEmployee
};
var result = n.Calculate(e);
Assert.IsTrue(original == result);
}
public async Task <EmployeeDto> GetEmployeeById(int id)
{
var emp = await repository.Get(id);
return(new EmployeeDto
{
id = emp.id,
roleName = emp.roleName,
roleDescription = emp.roleDescription,
hourlySalary = emp.hourlySalary,
contractTypeName = emp.contractTypeName,
monthlySalary = emp.monthlySalary,
name = emp.name,
roleId = emp.roleId,
annualSalary = SalaryFactory.Get((ContractEmun)Enum.Parse(typeof(ContractEmun), emp.contractTypeName), emp.hourlySalary.Value, emp.monthlySalary.Value)
});
}
public async Task <List <EmployeeDto> > GetEmployees()
{
List <EmployeeDto> employees = new List <EmployeeDto>();
var empls = await repository.GetAll();
//Automapper
employees = empls.Select(s => new EmployeeDto
{
id = s.id,
name = s.name,
roleId = s.roleId,
roleDescription = s.roleDescription,
roleName = s.roleName,
hourlySalary = s.hourlySalary,
monthlySalary = s.monthlySalary,
annualSalary = SalaryFactory.Get((ContractEmun)Enum.Parse(typeof(ContractEmun), s.contractTypeName), s.hourlySalary.Value, s.monthlySalary.Value)
}).ToList();
return(employees);
}
public void GetSalary(TypeSalary key,
params uint[] value)
{
switch (key)
{
case TypeSalary.Hourly:
{
EmployeeBase salary = SalaryFactory.GetSalary(TypeSalary.Hourly, 140, 400);
EmployeeHourly result = salary as EmployeeHourly;
Assert.AreSame(salary, result);
break;
}
case TypeSalary.Rate:
{
EmployeeBase salary = SalaryFactory.GetSalary(TypeSalary.Rate, 180, 100000, 180);
EmployeeRate result = salary as EmployeeRate;
Assert.AreSame(salary, result);
break;
}
}
}
/// <summary>
/// Кнопка добавления случайного объекта
/// </summary>
private void AddRandomObject_Click(object sender, EventArgs e)
{
var randomCase = new Random();
var random = new Random();
uint workTime = (uint)random.Next(1, 372);
switch (randomCase.Next(1, 3))
{
case 1:
{
uint costPerHour = (uint)random.Next(1, 1400);
bindingSource.Add(SalaryFactory.GetSalary(TypeSalary.Hourly, workTime, costPerHour));
break;
}
case 2:
{
uint rate = (uint)random.Next(1, 372);
uint salary = (uint)random.Next(1, 1000000);
bindingSource.Add(SalaryFactory.GetSalary(TypeSalary.Rate, workTime, salary, rate));
break;
}
}
}
public ResultData <List <Employee> > GetEmployees(Employee employee)
{
SalaryFactory factory = new SalaryFactory();
ResultData <List <Employee> > Result = new ResultData <List <Employee> >();
List <Employee> resultListEmployee = new Employees().GetEmployees().Where(item => item.id == employee.id).ToList();
foreach (Employee emp in resultListEmployee)
{
ISalary salary = factory.Create(emp);
emp.totalSalary = salary.TotalSalary();
}
if (resultListEmployee == null)
{
Result.Result = false;
Result.Message = "Fail service";
}
else
{
Result.Result = true;
Result.Data = resultListEmployee;
}
return(Result);
}
public IEnumerable <EmployeeDTO> getCalculatedSalaryByEmployee(IEnumerable <EmployeeDTO> employees, SalaryFactory factory)
{
foreach (var item in employees)
{
if (item.contractTypeName == "HourlySalaryEmployee")
{
ISalaryFactory factoryHourly = factory.GetCalculatedSalary(item.contractTypeName);
item.AnnualSalary = factoryHourly.calculateSalary(item.hourlySalary);
}
else if (item.contractTypeName == "MonthlySalaryEmployee")
{
ISalaryFactory factoryMonthly = factory.GetCalculatedSalary(item.contractTypeName);
item.AnnualSalary = factoryMonthly.calculateSalary(item.monthlySalary);
}
}
return(employees);
}