public void 算薪水()
{
var salaryFormula = new SalaryFormula();
var test = new SalaryCalculator(salaryFormula);
test.Calculate(10, 10, 0);
}
public void Calculate_WhenGrossPackageIsValid_ReturnsCorrectSalary(decimal grossPackage,
decimal expectedSuperannuation, decimal expectedTaxableIncome, decimal expectedNetIncome,
decimal expectedPayPacket)
{
//Arrange
var sc = new ServiceContainer();
sc.Register <SalaryDetails>((c) =>
{
var medicareLevyDeduction = c.GetInstance <MedicareLevyDeduction>();
var budgetRepairLevyDeduction = c.GetInstance <BudgetRepairLevyDeduction>();
var incomeTaxDeduction = c.GetInstance <IncomeTaxDeduction>();
return(new SalaryDetails(medicareLevyDeduction, budgetRepairLevyDeduction, incomeTaxDeduction));
}, new PerContainerLifetime());
sc.Register <MedicareLevyDeduction>();
sc.Register <BudgetRepairLevyDeduction>();
sc.Register <IncomeTaxDeduction>();
var sut = new SalaryCalculator(sc);
//Act
var salaryDetails = sut.Calculate(grossPackage, PayFrequency.Monthly);
//Assert
salaryDetails.Superannuation.Should().Be(expectedSuperannuation);
salaryDetails.TaxableIncome.Should().Be(expectedTaxableIncome);
salaryDetails.NetIncome.Should().Be(expectedNetIncome);
salaryDetails.PayPacket.Should().Be(expectedPayPacket);
}
public SalaryView()
{
Thread.CurrentThread.CurrentUICulture = CultureInfo.GetCultureInfo("cz-CZ");
InitializeComponent();
int count = 0;
StringBuilder result = new StringBuilder();
calc = new SalaryCalculator();
foreach (List <SalaryResultDTO> emp in calc.calcSalaryForAll(Employee.getList()))
{
result.AppendLine("Jméno a příjmení: " + emp[count].employee.FirstName + " " + emp[count].employee.LastName);
foreach (SalaryResultDTO month in emp)
{
string monthName = new DateTime(2019, month.Month, 1).ToString("MMMM", CultureInfo.GetCultureInfo("cz-CZ"));
result.AppendLine(" Měsíc: " + monthName);
result.AppendLine(" Hzubá mzda: " + month.GrossWage);
result.AppendLine(" Počet hodin: " + month.Hours);
result.AppendLine(" Čistá mzda: " + month.Wage);
result.AppendLine(" Sociální pojištění: " + month.SocialInsurance);
result.AppendLine(" Zdravotní pojištění: " + month.HealthInsurance);
result.AppendLine("");
}
count++;
}
textBox.Text = result.ToString();
}
private void btnSalaryCalculator_Click(object sender, RoutedEventArgs e)
{
using (var context = new CupOfCoffeeContext())
{
try
{
var pdfFile = new PdfFile();
pdfFile.filename = "..\\..\\..\\PDFReport\\employee-sallaries.pdf";
pdfFile.title = "Report: Employees sallaries";
pdfFile.data = SalaryCalculator.Calculate(context);
PdfCreator.Create(pdfFile);
SalaryRecorder.Insert(pdfFile.data, context);
//var pathToAcroRd32 = Environment.GetEnvironmentVariable("ProgramFiles") + @"\Adobe\Reader 11.0\Reader\AcroRd32.exe";
//var adobeInfo = new ProcessStartInfo(pathToAcroRd32, pdfFile.filename);
MessageBox.Show("The report for employees was successfully generated!",
"Generated successfully",
MessageBoxButton.OK,
MessageBoxImage.Information);
Process.Start(pdfFile.filename);
}
catch (Exception)
{
MessageBox.Show("Cannot generate the report for employees!",
"Generation failed",
MessageBoxButton.OK,
MessageBoxImage.Error);
}
}
}
public void SalaryCalculatorShouldReturnCorrectValue()
{
var salaryString = "3400";
var grossSalary = 3400m;
var taxesCalculator = TaxCalculatorServiceMock.New;
taxesCalculator
.Setup(x => x.ShouldApplyTax(grossSalary))
.Returns(true);
taxesCalculator
.Setup(x => x.IncomeTax(grossSalary))
.Returns(240);
taxesCalculator
.Setup(x => x.SocialTax(grossSalary))
.Returns(300);
var salaryValidation = SalaryValidationServiceMock.New;
salaryValidation
.Setup(x => x.IsValid(salaryString))
.Returns(true);
var salaryCalculator = new SalaryCalculator(taxesCalculator.Object, salaryValidation.Object);
var result = salaryCalculator.CalculateNetSalary(salaryString);
result
.Should()
.Be(2860);
}
static void Main(string[] args)
{
SalaryCalculator salaryCalculate = new SalaryCalculator();
//string filePath = args[0];
string filePath = "c:\\temp\\employeeDetail.csv";
Reader fileReader = new CsvReader();
List <Model.Employee> employees = fileReader.Read <Model.Employee>(filePath);
//Testing
//var employees = GetEmployeeData();
List <Model.Payslip> paySlips = salaryCalculate.CalculateTax(employees);
PrintPayslip(paySlips);
Writer fileWriter = new CsvWriter();
fileWriter.Write <Model.PayslipReport>(paySlips.Select(x =>
new PayslipReport
{
FullName = x.FullName,
PayPeriod = x.PayPeriod,
GrossIncome = x.GrossIncome,
IncomeTax = x.IncomeTax,
NetIncome = x.NetIncome,
Super = x.Super
}).ToList(), "c:\\temp\\EmployeePaySlip.csv");
Console.ReadKey();
}
public static int Main(string[] args)
{
if (args.Length != 2)
{
Console.WriteLine("Wrong args! Please enter input and output file names");
return(1);
}
IDataOperations dataOperations = new CsvDataOperations(args[0], args[1]);
IInputValidator inputValidator = new InputValidator();
var inputs = dataOperations.GetData();
if (inputs.Any(x => !inputValidator.Validate(x)))
{
Console.WriteLine("Wrong input data! Please correct your data");
return(2);
}
Console.WriteLine("Calculating...");
ISalaryCalculator calculator = new SalaryCalculator(GetTaxOptions());
var ouputs = inputs.Select(calculator.Calculate);
dataOperations.SaveData(ouputs);
Console.WriteLine($"Data was processed and saved to file {args[1]}");
return(0);
}
static void PrintSalary(SalaryCalculator all)
{
Console.Write($"{all.employeeName} has worked {all.hoursWorked} hours on the relevant week.");
Console.WriteLine($"The hourly pay of {all.employeeName} is {all.hourlyPay}.");
Console.WriteLine($"He/she has {all.ExcessHours()} hour(s) overtime.");
Console.WriteLine($"The total pay for the week of {all.employeeName} is {(all.OverTime() + all.NormalHours()) * all.hourlyPay}.\n");
}
private static void Main()
{
A:
try
{
double basicSalary, currentSalary;
Console.WriteLine("Enter BS - Basic Salary ");
basicSalary = double.Parse(Console.ReadLine());
Console.WriteLine("Enter CS - Current Salary ");
currentSalary = double.Parse(Console.ReadLine());
var action = new SalaryCalculator(new SalaryOverview(basicSalary, currentSalary));
Console.WriteLine(action);
}
catch (FormatException)
{
//if (!basicSalary.IsNumeric() || !currentSalary.IsNumeric())
//{
Console.WriteLine("Entered value is not numeric");
goto A;
//}
}
Console.ReadKey();
}
public void CalculateTotalSalaries_Calculated()
{
List <BaseSalaryCalculator> data = new List <BaseSalaryCalculator>
{
new JuniorDevSalaryCalculator(new DeveloperReport {
Id = 1, Name = "ho", Level = "Junior", HourlyRate = 1.0, WorkingHours = 100
}),
new SeniorDevSalaryCalculator(new DeveloperReport {
Id = 2, Name = "so", Level = "Senior", HourlyRate = 0.5, WorkingHours = 200
}),
new JuniorDevSalaryCalculator(new DeveloperReport {
Id = 3, Name = "ka", Level = "Junior", HourlyRate = 2.0, WorkingHours = 50
}),
new SeniorDevSalaryCalculator(new DeveloperReport {
Id = 4, Name = "wa", Level = "Senior", HourlyRate = 2.5, WorkingHours = 40
})
};
SalaryCalculator calc = new SalaryCalculator(data);
double actual = calc.CalculateTotalSalaries();
double expected = 440D;
Assert.Equal(expected, actual);
}
public void Should_Be_Correct_Monthly_Gross_Salary()
{
SalaryCalculator salaryCalculator = new SalaryCalculator(_mockTaxCalculator.Object);
var salary = salaryCalculator.CalculateSalary(60050, 9);
salary.GrossSalary.ShouldEqual(5004);
}
public void Obliczenia_dla_wynagrodzenie_netto
(decimal salary, bool higherCostOfGettingIncome, bool hasHealthInsurance, decimal exceptetBrutto, decimal exceptetPit, decimal exceptetInsurance)
{
//Arrange
var contractBuilder = new ContractBuilder();
contractBuilder.TypeOfContract(TypeOfContract.UmowaZlecenie);
contractBuilder.Salary(salary, SalaryFrom.Net);
if (higherCostOfGettingIncome)
{
contractBuilder.HigherCostOfGettingIncome(true);
}
if (hasHealthInsurance)
{
contractBuilder.HealthInsurance();
}
var contract = contractBuilder.Build();
//Act
var calculator = new SalaryCalculator(contract);
var result = calculator.Calculator();
//Assert
Assert.Equal(exceptetBrutto, result.GrossSalary);
Assert.Equal(exceptetPit, result.SalaryCosts.First(x => x.CostName == "zaliczka na PIT").CostValue);
if (hasHealthInsurance)
{
Assert.Equal(exceptetInsurance, result.SalaryCosts.First(x => x.CostName == "ubezpieczenie zdrowotne").CostValue);
}
}
static void Main(string[] args)
{
//一般員工(以Container方式實現DI)
using (IUnityContainer container = new UnityContainer())
{
UnityConfigurationSection section = (UnityConfigurationSection)ConfigurationManager.GetSection("unity");
//只有container不同
section.Configure(container, "containerEmployee");
//其他code完全相同
SalaryCalculator SC = container.Resolve <SalaryCalculator>();
float amount = SC.Calculate(8 * 19, 200, 8);
Console.Write("\nSalaryFormula--->amount:" + amount);
Console.ReadKey();
}
//老闆
using (IUnityContainer container = new UnityContainer())
{
UnityConfigurationSection section = (UnityConfigurationSection)ConfigurationManager.GetSection("unity");
//只有container不同
section.Configure(container, "containerBoss");
//其他code完全相同
SalaryCalculator SC = container.Resolve <SalaryCalculator>();
float amount = SC.Calculate(8 * 19, 200, 8);
Console.Write("\nSalaryFormula--->amount:" + amount);
Console.ReadKey();
}
}
public void ShouldGive10PercentDiscountIfSalaryIsLessThanLimit()
{
var salary = 3000m;
var developer = new Employee(name: "Fleta Balistreri", salary, Role.Developer);
Assert.AreEqual(2700m, SalaryCalculator.Calculate(developer));
}
private void _initializeDataContext()
{
IRepository employeeRepository = new Repository();
ISalaryCalculator salaryCalculator = new SalaryCalculator();
DataContext = new MainWindowViewModel(employeeRepository, salaryCalculator);
}
static void Main()
{
SalaryCalculator salaryCalculator1 = new SalaryCalculator();
SalaryCalculator salaryCalculator2 = new SalaryCalculator();
SalaryCalculator salaryCalculator3 = new SalaryCalculator();
Console.Write("Please enter the name of the 1st employee: ");
string salaryCalculator1theEmployeetheName = Console.ReadLine();
salaryCalculator1.SetEmployeeName(salaryCalculator1theEmployeetheName);
Console.Write($"Please enter the hourly wage of {salaryCalculator1.GetEmployeeName()}: ");
decimal salaryCalculator1theHourlyPay = decimal.Parse(Console.ReadLine());
salaryCalculator1.SetHourlyPay(salaryCalculator1theHourlyPay);
Console.Write($"Please enter the hours worked by {salaryCalculator1.GetEmployeeName()}: ");
int salaryCalculator1theHoursWorked = int.Parse(Console.ReadLine());
salaryCalculator1.SetHoursWorked(salaryCalculator1theHoursWorked);
Console.Write("\n\nPlease enter the name of the 2nd employee: ");
string salaryCalculator2theEmployeetheName = Console.ReadLine();
salaryCalculator2.SetEmployeeName(salaryCalculator2theEmployeetheName);
Console.Write($"Please enter the hourly wage of {salaryCalculator2.GetEmployeeName()}: ");
decimal salaryCalculator2theHourlyPay = decimal.Parse(Console.ReadLine());
salaryCalculator2.SetHourlyPay(salaryCalculator2theHourlyPay);
Console.Write($"Please enter the hours worked by {salaryCalculator2.GetEmployeeName()}: ");
int salaryCalculator2theHoursWorked = int.Parse(Console.ReadLine());
salaryCalculator2.SetHoursWorked(salaryCalculator2theHoursWorked);
Console.Write("\n\nPlease enter the name of the 3rd employee: ");
string salaryCalculator3theEmployeetheName = Console.ReadLine();
salaryCalculator3.SetEmployeeName(salaryCalculator3theEmployeetheName);
Console.Write($"Please enter the hourly wage of {salaryCalculator3.GetEmployeeName()}: ");
decimal salaryCalculator3theHourlyPay = decimal.Parse(Console.ReadLine());
salaryCalculator3.SetHourlyPay(salaryCalculator3theHourlyPay);
Console.Write($"Please enter the hours worked by {salaryCalculator3.GetEmployeeName()}: ");
int salaryCalculator3theHoursWorked = int.Parse(Console.ReadLine());
salaryCalculator3.SetHoursWorked(salaryCalculator3theHoursWorked);
Console.Write("\n\n");
PrintSalary(salaryCalculator1);
PrintSalary(salaryCalculator2);
PrintSalary(salaryCalculator3);
}
public void Test2()
{
SalaryCalculator salaryCalculator = new SalaryCalculator();
decimal hourlyWage = salaryCalculator.GetHourlyWage(93600);
Assert.Equal(40, hourlyWage);
}
public IActionResult GetWithSalary()
{
return(Ok(m_context.Employees.Select(
x => SalaryCalculator.Calculate(x,
m_context.BaseSalaries.FirstOrDefault(y =>
y.Position == x.Position && y.ExperienceFrom <= x.ExperienceYears && y.ExperienceTo >= x.ExperienceYears)))
));
}
public void ShouldObtainTheJuniorsTotalSalary()
{
var calculatorContext = new SalaryCalculator(new JuniorDevSalaryCalculator());
var juniorsTotalSalary = calculatorContext.Calculate(_reports);
juniorsTotalSalary.Should().Be(5830);
}
public void Calculate_WhenProvidedNull_ReturnsEmpty()
{
var calculator = new SalaryCalculator();
var result = calculator.Calculate(null);
result.ShouldBeEmpty();
}
public void ShouldObtainTheSeniorsTotalSalary()
{
var calculatorContext = new SalaryCalculator(new SeniorDevSalaryCalculator());
var seniorsTotalSalary = calculatorContext.Calculate(_reports);
seniorsTotalSalary.Should().Be(10926);
}
public void SalaryCalculation_HoursMoreThanAllowed_ReturnsCalculationErrorMessage()
{
//arrange
const string expected = "Employee 1: Error in salary calculation!";
//act
var actual = SalaryCalculator.SalaryCalculation("Employee 1", 8.50, 660);
//assert
Assert.Equal(expected, actual);
}
public void Should_Be_Correct_Monthly_Gross_Salary()
{
_mockTaxCalculator.Setup(t => t.CalculateTax(It.IsAny <decimal>())).Returns(922);
_mockSuperCalculator.Setup(t => t.CalculateSuper(It.IsAny <decimal>(), It.IsAny <decimal>())).Returns(450);
SalaryCalculator calculator = new SalaryCalculator(_mockTaxCalculator.Object, _mockSuperCalculator.Object);
var salary = calculator.CalculateSalary(60050, 9);
salary.GrossSalary.ShouldEqual(5004);
}
public void ShouldGive15PercentDiscountIfSalaryIsLessThanLimit()
{
var salary = 2500m;
var dba = new Employee(name: "Fleta Balistreri", salary, Role.DBA);
var tester = new Employee(name: "Fleta Balistreri", salary, Role.Tester);
Assert.AreEqual(2125m, SalaryCalculator.Calculate(dba));
Assert.AreEqual(2125m, SalaryCalculator.Calculate(tester));
}
public void SalaryCalculation_CalculateSalaryNoOvertime_ReturnsCalculatedSalary()
{
//arrange
const string expected = "Employee 2 salary is: 320.00";
//act
var actual = SalaryCalculator.SalaryCalculation("Employee 2", 8.00, 40);
//assert
Assert.Equal(expected, actual);
}
public void TestNull()
{
var c = new SalaryCalculator(SalaryArgs);
Assert.ThrowsException <ArgumentNullException>(() => c.CalculateSalary((Employee)null));
Assert.ThrowsException <ArgumentNullException>(() => c.CalculateSalary((ManagerEmployee)null));
Assert.ThrowsException <ArgumentNullException>(() => c.CalculateSalary((SalesEmployee)null));
Assert.ThrowsException <ArgumentNullException>(() => c.CalculateSalary((List <Employee>)null));
}
public void Should_Be_Correct_Net_Salary()
{
_mockTaxCalculator.Setup(t => t.CalculateTax(It.IsAny <decimal>())).Returns(922);
_mockSuperCalculator.Setup(t => t.CalculateSuper(It.IsAny <decimal>(), It.IsAny <decimal>())).Returns(450);
SalaryCalculator calculator = new SalaryCalculator(_mockTaxCalculator.Object, _mockSuperCalculator.Object);
var salary = calculator.CalculateSalary(60050, 9);
salary.NetIncome.ShouldEqual(4082);
}
public void Calculate_WhenProvidedInvalidEmployee_ReturnsEmpty()
{
var employee = new Employee();
var calculator = new SalaryCalculator();
var result = calculator.Calculate(employee);
employee.IsValid().ShouldBeFalse();
result.ShouldBeEmpty();
}
public void AnnualSalaryTest()
{
// Arrange
var sc = new SalaryCalculator();
// Act
decimal annunalSalary = sc.GetAnnualSalary(50);
// Assert
Assert.AreEqual(104000, annunalSalary);
}
public void HourlyWageTest()
{
// Arrange
var sc = new SalaryCalculator();
// Act
decimal hourlyWage = sc.GetHourlyWage(52000);
// Assert
Assert.AreEqual(25, hourlyWage);
}
