public frmPayrollManagement(IEmployeeService empSvc, IDropdownService drp, IDtrService dsvc, IPayrollService payrollService)
{
this.empSvc = empSvc;
this.drp = drp;
this.dsvc = dsvc;
_payrollService = payrollService;
}
public AccountingBaseController(IAccountingWorkData accountingWorkData, IPayrollService payrollService, IMapper mapper, IEventsFactory eventsFactory)
{
this.AccountingWorkData = accountingWorkData;
this.PayrollService = payrollService;
this.Mapper = mapper;
this.EventsFactory = eventsFactory;
}
public AddPaycheckPaymentViewComponent(
IAccountingWorkData accountingWorkData,
IPayrollService payrollService,
IMapper mapper,
IEventsFactory eventsFactory)
: base(accountingWorkData, payrollService, mapper, eventsFactory)
{
}
public PayrollController(
IAccountingWorkData accountingWorkData,
IPayrollService payrollService,
IMapper mapper,
IEventsFactory eventsFactory)
: base(accountingWorkData, payrollService, mapper, eventsFactory)
{
}
public async static Task <ReviewPaychecksViewModel> CreateAsync(IPayrollService services)
{
return(new ReviewPaychecksViewModel()
{
EmployeeOptions = await services.GetShdeduleEmployeeOptions(),
PeriodOptions = services.GetPeriodsOptions()
});
}
public static IndexViewModel Create(IPayrollService services, string message = null)
{
return(new IndexViewModel()
{
Message = message ?? string.Empty,
PeriodOptions = services.GetPeriodsOptions()
});
}
public async Task <IActionResult> Save([FromServices] IPayrollService payrollService, [FromBody] SaveEmployeeRequest request)
{
var employee = _mapper.Map <Employee>(request.Employee);
payrollService.CalculatePay(employee);
await _employeeRepository.Add(employee);
return(NoContent());
}
public static async Task <PayrollViewModel> CreateAsync(IPayrollService services)
{
return(new PayrollViewModel()
{
From = DateTime.Today.AddMonths(-1),
To = DateTime.Today,
EmployeeOptions = await services.GetAccountingEmployeeOptions()
});
}
public EmployeesController(
IMapper mapper,
IEmployeeComponent employeeComponent,
IPayrollService payrollService
)
{
_mapper = mapper;
_employeeComponent = employeeComponent;
_payrollService = payrollService;
}
public PayrollsController(
IBaseRepository <Employee> repository,
IBaseRepository <Payroll> payrollRepository,
IPayrollService payrollService
)
{
_employeeRepository = repository;
_payrollRepository = payrollRepository;
_payrollService = payrollService;
}
public async Task <ActionResult <EmployeeResponse> > UpdateEmployee(int id, [FromServices] IPayrollService payrollService, [FromBody] SaveEmployeeRequest request)
{
var employee = await _employeeRepository.Get(id);
_mapper.Map(request.Employee, employee);
payrollService.CalculatePay(employee);
await _employeeRepository.SaveChanges();
return(NoContent());
}
public ActionResult <PreviewEmployeeCostsResponse> PreviewCosts([FromServices] IPayrollService payrollService, [FromBody] PreviewEmployeeCostRequest request)
{
var response = new PreviewEmployeeCostsResponse();
var employee = _mapper.Map <Employee>(request.Employee);
payrollService.CalculatePay(employee);
response.AnnualPay = _mapper.Map <EmployeePayDto>(employee.AnnualPay);
response.PaycheckPay = _mapper.Map <EmployeePayDto>(employee.PaycheckPay);
return(response);
}
public PayrollController(
ISchedulerWorkData schedulerWorkData,
IMapper mapper,
IPayrollService payrollService,
IEventsFactory eventsFactory)
: base(schedulerWorkData, mapper, eventsFactory)
{
this.PayrollService = payrollService;
this.PayrollService.SchedulerWorkData = schedulerWorkData;
}
public BaseViewComponent(
IAccountingWorkData accountingWorkData,
IPayrollService payrollService,
IMapper mapper,
IEventsFactory eventsFactory)
{
this.AccountingWorkData = accountingWorkData;
this.PayrollService = payrollService;
this.Mapper = mapper;
this.EventsFactory = eventsFactory;
}
public PayCodeBatchRunner(ISessionStorage store, ISystemService system, ICompanyStructureService main, IPayrollService payrollService) : base(system, main)
{
this.SessionStore = store;
SessionHelper h = new SessionHelper(store, new APIKeyBasedTokenGenerator());
BatchStatus = new BatchOperationStatus()
{
classId = ClassId.PYPC, processed = 0, tableSize = 0, status = 0
};
_payrollService = payrollService;
payCodes = new Dictionary <string, string>();
}
public EmployeeComponent(
IConfiguration configuration,
IMapper mapper,
IEmployeeRepository employeeRepository,
IBenefitEvaluator benefitEvaluator,
IPayrollService payrollService
)
{
_mapper = mapper;
_employeeRepository = employeeRepository;
_configuration = configuration;
_benefitEvaluator = benefitEvaluator;
_payrollService = payrollService;
}
public async static Task <ReviewPaychecksViewModel> CreateAsync(
ReviewPaychecksViewModel model,
DateTime from,
DateTime to,
IPayrollService services,
IMapper mapper)
{
var employees = await services.GetEmployees();
var employeeModels = mapper.Map <IEnumerable <Employee>, IEnumerable <EmployeeViewModel> >(employees);
employeeModels.ToList().ForEach(e =>
e.Paychecks = e.Paychecks.Where(p => from <= p.Period.From && to >= p.Period.To).OrderBy(p => p.Period.From));
model.EmployeeOptions = await services.GetShdeduleEmployeeOptions();
model.PeriodOptions = services.GetPeriodsOptions();
model.Employees = employeeModels;
return(model);
}
public static async Task <PayrollViewModel> CreateAsync(
DateTime from,
DateTime to,
string employeeId,
IPayrollService services,
IMapper mapper)
{
var model = await PayrollViewModel.CreateAsync(services);
var employees = await services.GetEmployeesWihtPayrolls(employeeId);
var employeessWithFilteredPaycheks = services.FilterEmployeesPaycheksByDate(from, to, employees);
model.Employees = mapper.Map <IEnumerable <Employee>, IEnumerable <EmployeeViewModel> >(employeessWithFilteredPaycheks);
model.From = from;
model.To = to;
model.TotalPaycheksSum = employees.Sum(e => e.Paycheks.Select(p => p.Total).Sum());
model.TotalPaymentsSum = employees.Sum(e => e.Paycheks.Select(p => p.GetPaidAmount()).Sum());
model.TotalDiffrenceToBePayed = model.TotalPaycheksSum - model.TotalPaymentsSum;
return(model);
}
public PayrollServiceController(IPayrollService payrollService)
{
this._payrollService = payrollService;
}
public PayrollController(IPayrollService service, IPayrollValidationService validation, IPayrollDataService dataService,
ILogger <PayrollController> logger, IPayrollApprovalService approvalService, IPayrollAdjustmentService adjustService)
=> (_service, _dataService, _validation, _logger, _approvalService, _adjustService)
public PayrollController(IPayrollService service)
{
this.service = service;
}
public async static Task <ReviewPaychecksViewModel> ReBuildAsync(ReviewPaychecksViewModel model, IPayrollService services)
{
model.EmployeeOptions = await services.GetShdeduleEmployeeOptions();
model.PeriodOptions = services.GetPeriodsOptions();
return(model);
}
public PayrollController(IPayrollService payrollService)
{
_payrollService = payrollService;
}
public NewPayrollShell()
{
InitializeComponent();
_payrollService = new PayrollService();
}
public PayrollController(IPayrollService payrollService) : base(payrollService, (int)MenuFeatureEnum.Payroll)
{
this.payrollService = payrollService;
}
public PayrollApiController(IServiceProvider serviceProvider, IDbMetadataContext metadataContext, IPayrollService payrollService) : base(serviceProvider)
{
_payrollService = payrollService;
_metadataContext = metadataContext;
}
public static async Task <PayrollViewModel> ReBuildAsync(PayrollViewModel model, IPayrollService services)
{
model.From = DateTime.Today.AddMonths(-1);
model.To = DateTime.Today;
model.EmployeeOptions = await services.GetAccountingEmployeeOptions();
return(model);
}
public PayrollController(IMapper mapper, UserManager <AppUser> userManager, IPayrollService payrollService)
{
_payrollService = payrollService;
_userManager = userManager;
_mapper = mapper;
}
public PayrollListener(IListener listener, IPayrollService payrollService)
{
_listener = listener;
_payrollService = payrollService;
}
