public void Should_Map_CalendarDto_to_Calendar()
{
// Arrange
var _mCalendar = new Mock <Calendar>();
var calendarDto = new CalendarDto
{
IsActive = true,
StartDate = _testDateTime,
EndDate = _testDateTime,
Name = _testNameString,
SiteId = 1,
SubSiteId = 1
};
// Act
CommonHelperAppService.MapDtoToEntityForUpdating(calendarDto, _mCalendar.Object);
// Assert
Assert.AreEqual(calendarDto.IsActive, _mCalendar.Object.IsActive);
Assert.AreEqual(calendarDto.StartDate, _mCalendar.Object.StartDate);
Assert.AreEqual(calendarDto.EndDate, _mCalendar.Object.EndDate);
Assert.AreEqual(calendarDto.Name, _mCalendar.Object.Name);
Assert.AreEqual(calendarDto.SiteId, _mCalendar.Object.SiteId);
Assert.AreEqual(calendarDto.SubSiteId, _mCalendar.Object.SubSiteId);
}
public IHttpActionResult UpdateShiftProfile(ShiftProfileModel shiftProfileModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
//var shiftProfileDto = Mapper.Map<ShiftProfileDto>(shiftProfileModel);
var shiftProfileDto = _shiftProfileAppService.GetById(shiftProfileModel.Id);
shiftProfileDto.Reason = shiftProfileModel.Reason;
shiftProfileDto.Notes = shiftProfileModel.Notes;
shiftProfileDto.ActualStartDateTime = shiftProfileModel.ActualStartDateTime;
shiftProfileDto.ActualEndDateTime = shiftProfileModel.ActualEndDateTime;
shiftProfileDto.IsApproved = shiftProfileModel.IsApproved;
shiftProfileDto.IsModified = shiftProfileModel.IsModified;
shiftProfileDto.HoursWorked =
CommonHelperAppService.ReturnCalculatedTimespanBetweenTwoDateTimeObjects(
shiftProfileDto.ActualStartDateTime, shiftProfileDto.ActualEndDateTime, 0);
_shiftProfileAppService.Update(shiftProfileDto, AuthHelper.GetCurrentUserId());
return(Ok("Shift Profile Updated"));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public void Update(CalendarResourceRequirementDto calendarResourceRequirementDto, long userId)
{
var calResRq =
_unitOfWork.CalendarResourceRequirementRepository.GetById(calendarResourceRequirementDto.Id);
if (calResRq.StartDate < calendarResourceRequirementDto.StartDate)
{
calendarResourceRequirementDto.StartDate = calResRq.StartDate;
}
if (calResRq.EndDate > calendarResourceRequirementDto.EndDate)
{
// keep existing start date for existing cal res req lines.
calendarResourceRequirementDto.EndDate = calResRq.EndDate;
}
CommonHelperAppService.MapDtoToEntityForUpdating(calendarResourceRequirementDto, calResRq);
_unitOfWork.CalendarResourceRequirementRepository.Update(calResRq);
_unitOfWork.Save();
// Audit
_auditLogAppService.Audit(
AppConstants.ActionTypeUpdate,
AppConstants.CalendarResourceRequirementTableName,
userId,
calResRq.Id);
}
public void Should_Map_UserDto_to_User()
{
// Arrange
var _mUser = new Mock <User>();
var userDto = new UserDto
{
IsActive = true,
Email = _testEmailString,
Firstname = _testNameString,
Lastname = _testNameString,
Password = _testNameString,
IsAccountLocked = false,
Login = _testNameString,
SystemAccessRoleId = 1
};
// Act
CommonHelperAppService.MapDtoToEntityForUpdating(userDto, _mUser.Object);
// Assert
Assert.AreEqual(userDto.IsActive, _mUser.Object.IsActive);
Assert.AreEqual(userDto.Email, _mUser.Object.Email);
Assert.AreEqual(userDto.Firstname, _mUser.Object.Firstname);
Assert.AreEqual(userDto.Lastname, _mUser.Object.Lastname);
Assert.AreEqual(userDto.Password, _mUser.Object.Password);
Assert.AreEqual(userDto.IsAccountLocked, _mUser.Object.IsAccountLocked);
Assert.AreEqual(userDto.Login, _mUser.Object.Login);
Assert.AreEqual(userDto.SystemAccessRoleId, _mUser.Object.SystemAccessRoleId);
}
public void Should_Map_BudgetPeriodDto_to_BudgetPeriod()
{
// Arrange
var _mBudgetPeriod = new Mock <BudgetPeriod>();
var budgetPeriodDto = new BudgetPeriodDto
{
IsActive = true,
StartDate = _testDateTime,
EndDate = _testDateTime,
ActualSpendTotal = 1000,
Amount = 1001,
ForecastTotal = 1200
};
// Act
CommonHelperAppService.MapDtoToEntityForUpdating(budgetPeriodDto, _mBudgetPeriod.Object);
// Assert
Assert.AreEqual(budgetPeriodDto.IsActive, _mBudgetPeriod.Object.IsActive);
Assert.AreEqual(budgetPeriodDto.StartDate, _mBudgetPeriod.Object.StartDate);
Assert.AreEqual(budgetPeriodDto.EndDate, _mBudgetPeriod.Object.EndDate);
Assert.AreEqual(budgetPeriodDto.ActualSpendTotal, _mBudgetPeriod.Object.ActualSpendTotal);
Assert.AreEqual(budgetPeriodDto.Amount, _mBudgetPeriod.Object.Amount);
Assert.AreEqual(budgetPeriodDto.ForecastTotal, _mBudgetPeriod.Object.ForecastTotal);
}
public bool Login(string login, string password)
{
// validate password
var hashToCheck = CommonHelperAppService.HashPassword(password);
return(CommonHelperAppService.ValidatePassword(password, hashToCheck));
}
public void Should_Map_BudgetDto_to_Budget()
{
// Arrange
var _mBudget = new Mock <Budget>();
var budgetDto = new BudgetDto
{
IsActive = true,
ActualTotal = 100,
ForecastTotal = 120,
StartDate = _testDateTime,
EndDate = _testDateTime,
SiteId = 1,
SubSiteId = null
};
// Act
CommonHelperAppService.MapDtoToEntityForUpdating(budgetDto, _mBudget.Object);
// Assert
Assert.AreEqual(budgetDto.IsActive, _mBudget.Object.IsActive);
Assert.AreEqual(budgetDto.ActualTotal, _mBudget.Object.ActualTotal);
Assert.AreEqual(budgetDto.ForecastTotal, _mBudget.Object.ForecastTotal);
Assert.AreEqual(budgetDto.StartDate, _mBudget.Object.StartDate);
Assert.AreEqual(budgetDto.EndDate, _mBudget.Object.EndDate);
Assert.AreEqual(budgetDto.SiteId, _mBudget.Object.SiteId);
Assert.AreEqual(budgetDto.SubSiteId, _mBudget.Object.SubSiteId);
}
public void Should_Map_ShiftDto_to_Shift()
{
// Arrange
var _mShift = new Mock <Shift>();
var shiftDto = new ShiftDto
{
IsActive = true,
IsAssigned = true,
ShiftTemplateId = 1,
CalendarResourceRequirementId = 1,
StartDate = new DateTime(),
EndDate = new DateTime(),
EmployeeId = 1
};
// Act
CommonHelperAppService.MapDtoToEntityForUpdating(shiftDto, _mShift.Object);
// Assert
Assert.AreEqual(shiftDto.IsActive, _mShift.Object.IsActive);
Assert.AreEqual(shiftDto.IsAssigned, _mShift.Object.IsAssigned);
Assert.AreEqual(shiftDto.ShiftTemplateId, _mShift.Object.ShiftTemplateId);
Assert.AreEqual(shiftDto.StartDate, _mShift.Object.StartDate);
Assert.AreEqual(shiftDto.EndDate, _mShift.Object.EndDate);
Assert.AreEqual(shiftDto.EmployeeId, _mShift.Object.EmployeeId);
}
public void Should_Map_ShiftProfileDto_to_ShiftProfile()
{
// Arrange
var _mShiftProfile = new Mock <ShiftProfile>();
var shiftProfileDto = new ShiftProfileDto
{
IsActive = true,
StartDateTime = _testDateTime,
EndDateTime = _testDateTime,
EmployeeId = 1,
//HoursWorked = 12,
ShiftId = 1
};
// Act
CommonHelperAppService.MapDtoToEntityForUpdating(shiftProfileDto, _mShiftProfile.Object);
// Assert
Assert.AreEqual(shiftProfileDto.IsActive, _mShiftProfile.Object.IsActive);
Assert.AreEqual(shiftProfileDto.StartDateTime, _mShiftProfile.Object.StartDateTime);
Assert.AreEqual(shiftProfileDto.EndDateTime, _mShiftProfile.Object.EndDateTime);
Assert.AreEqual(shiftProfileDto.HoursWorked, _mShiftProfile.Object.HoursWorked);
Assert.AreEqual(shiftProfileDto.EmployeeId, _mShiftProfile.Object.EmployeeId);
Assert.AreEqual(shiftProfileDto.ShiftId, _mShiftProfile.Object.ShiftId);
}
public void Should_Map_LeaveReuquestDto_to_LeaveRequest()
{
// Arrange
var _mLeaveRequest = new Mock <LeaveRequest>();
var leaveRequestDto = new LeaveRequestDto
{
IsActive = true,
EmployeeId = null,
AmountRequested = 100,
StartDateTime = _testDateTime,
EndDateTime = _testDateTime,
IsApproved = true,
IsTaken = true,
LeaveTypeId = 1
};
// Act
CommonHelperAppService.MapDtoToEntityForUpdating(leaveRequestDto, _mLeaveRequest.Object);
// Assert
Assert.AreEqual(leaveRequestDto.IsActive, _mLeaveRequest.Object.IsActive);
Assert.AreEqual(leaveRequestDto.EmployeeId, _mLeaveRequest.Object.EmployeeId);
Assert.AreEqual(leaveRequestDto.AmountRequested, _mLeaveRequest.Object.AmountRequested);
Assert.AreEqual(leaveRequestDto.StartDateTime, _mLeaveRequest.Object.StartDateTime);
Assert.AreEqual(leaveRequestDto.EndDateTime, _mLeaveRequest.Object.EndDateTime);
Assert.AreEqual(leaveRequestDto.IsApproved, _mLeaveRequest.Object.IsApproved);
Assert.AreEqual(leaveRequestDto.IsTaken, _mLeaveRequest.Object.IsTaken);
Assert.AreEqual(leaveRequestDto.LeaveTypeId, _mLeaveRequest.Object.LeaveTypeId);
}
public void Should_map_PersonnelLeaveProfileDto_to_PersonnelLeaveProfile()
{
// Arrange
var _mProfile = new Mock <PersonnelLeaveProfile>();
var profileDto = new PersonnelLeaveProfileDto
{
IsActive = true,
EmployeeId = 1,
LeaveTypeId = 1,
Notes = _testNameString,
NumberOfDaysAllocated = 20,
NumberOfDaysRemaining = 10,
NumberOfDaysTaken = 10
};
// Act
CommonHelperAppService.MapDtoToEntityForUpdating(profileDto, _mProfile.Object);
// Assert
Assert.AreEqual(profileDto.IsActive, _mProfile.Object.IsActive);
Assert.AreEqual(profileDto.EmployeeId, _mProfile.Object.EmployeeId);
Assert.AreEqual(profileDto.LeaveTypeId, _mProfile.Object.LeaveTypeId);
Assert.AreEqual(profileDto.Notes, _mProfile.Object.Notes);
Assert.AreEqual(profileDto.NumberOfDaysAllocated, _mProfile.Object.NumberOfDaysAllocated);
Assert.AreEqual(profileDto.NumberOfDaysTaken, _mProfile.Object.NumberOfDaysTaken);
Assert.AreEqual(profileDto.NumberOfDaysRemaining, _mProfile.Object.NumberOfDaysRemaining);
}
public void Should_Map_EmployeeDto_to_Employee()
{
// Arrange
var _mEmployee = new Mock <Employee>();
var employeeDto = new EmployeeDto
{
IsActive = true,
Address = _testAddressString,
City = _testCityString,
Postcode = _testPostcodeString,
CompanyId = 1,
EmployeeTypeId = 1,
GenderId = 1
};
// Act
CommonHelperAppService.MapDtoToEntityForUpdating(employeeDto, _mEmployee.Object);
// Assert
Assert.AreEqual(employeeDto.IsActive, _mEmployee.Object.IsActive);
Assert.AreEqual(employeeDto.Address, _mEmployee.Object.Address);
Assert.AreEqual(employeeDto.City, _mEmployee.Object.City);
Assert.AreEqual(employeeDto.Postcode, _mEmployee.Object.Postcode);
Assert.AreEqual(employeeDto.CompanyId, _mEmployee.Object.CompanyId);
Assert.AreEqual(employeeDto.EmployeeTypeId, _mEmployee.Object.EmployeeTypeId);
Assert.AreEqual(employeeDto.GenderId, _mEmployee.Object.GenderId);
}
public void Should_Map_ContractDto_to_Contract()
{
// Arrange
var _mContract = new Mock <Contract>();
var contractDto = new ContractDto
{
IsActive = true,
EmployeeId = null,
BaseRateOverride = 1.25,
OvertimeModifierOverride = 2,
ResourceId = 1,
WeeklyHours = 40.5
};
// Act
CommonHelperAppService.MapDtoToEntityForUpdating(contractDto, _mContract.Object);
// Assert
Assert.AreEqual(contractDto.IsActive, _mContract.Object.IsActive);
Assert.AreEqual(contractDto.EmployeeId, _mContract.Object.EmployeeId);
Assert.AreEqual(contractDto.BaseRateOverride, _mContract.Object.BaseRateOverride);
Assert.AreEqual(contractDto.OvertimeModifierOverride, _mContract.Object.OvertimeModifierOverride);
Assert.AreEqual(contractDto.ResourceId, _mContract.Object.ResourceId);
Assert.AreEqual(contractDto.WeeklyHours, _mContract.Object.WeeklyHours);
}
public void Should_Map_CompanyDto_to_Company()
{
// Arrange
var _mCompany = new Mock <Company>();
var companyDto = new CompanyDto
{
IsActive = true,
Address = _testAddressString,
City = _testCityString,
Postcode = _testPostcodeString,
Telephone = _testTelephoneString,
Fax = _testFaxString,
ContactName = _testNameString,
Email = _testEmailString
};
// Act
CommonHelperAppService.MapDtoToEntityForUpdating(companyDto, _mCompany.Object);
// Assert
Assert.AreEqual(companyDto.IsActive, _mCompany.Object.IsActive);
Assert.AreEqual(companyDto.Address, _mCompany.Object.Address);
Assert.AreEqual(companyDto.City, _mCompany.Object.City);
Assert.AreEqual(companyDto.Postcode, _mCompany.Object.Postcode);
Assert.AreEqual(companyDto.Telephone, _mCompany.Object.Telephone);
Assert.AreEqual(companyDto.Fax, _mCompany.Object.Fax);
Assert.AreEqual(companyDto.ContactName, _mCompany.Object.ContactName);
Assert.AreEqual(companyDto.Email, _mCompany.Object.Email);
}
public bool PasswordReset(string emailAddress)
{
// get user based upon email address
var user = _unitOfWork.UserRepository.Get(u => u.Email == emailAddress).FirstOrDefault();
if (user != null)
{
// for use below with unhashed password
var userDto = Mapper.Map <UserDto>(user);
// generate new password from Random
userDto.Password = CommonHelperAppService.RandomString(8);
// Hash it. Hash it, real good!
user.Password = CommonHelperAppService.HashPassword(userDto.Password);
_unitOfWork.UserRepository.Update(user);
_unitOfWork.Save();
MailerService.SendPasswordResetEmail(userDto);
return(true);
}
return(false);
}
// CRUD
public long RegisterUserAccount(UserDto userDto, long userId)
{
// gen random string and hash
var unhashedPassword = CommonHelperAppService.RandomString(8);
userDto.Password = unhashedPassword;
var user = Mapper.Map <User>(userDto);
user.Password = HashPassword(unhashedPassword);
_unitOfWork.UserRepository.Create(user);
_unitOfWork.Save();
// Mail
MailerService.SendUserRegisteredEmail(userDto);
// Audit
_auditLogAppService.Audit(
AppConstants.ActionTypeCreate,
AppConstants.UserTableName,
userId,
user.Id);
return(user.Id);
}
public bool VerifyPassword(string enteredPassword, string retrievedPassword)
{
var isValid = CommonHelperAppService.ValidatePassword(enteredPassword, retrievedPassword);
if (!isValid)
{
return(false);
}
return(true);
}
public void Should_Map_ShiftTemplateDto_to_ShiftTemplate()
{
// Arrange
var _mshiftTemplate = new Mock <ShiftTemplate>();
var shiftTemplateDto = new ShiftTemplateDto
{
IsActive = true,
Duration = 8.5,
EndTime = DateTime.UtcNow,
StartTime = DateTime.UtcNow,
Name = "RMN Day",
ShiftRate = 9.5m,
ResourceId = 1,
SiteId = 13,
SubSiteId = null,
UnpaidBreakDuration = 0.5,
Mon = true,
Tue = true,
Wed = true,
Thu = true,
Fri = true,
Sat = false,
Sun = false
};
// Act
CommonHelperAppService.MapDtoToEntityForUpdating(shiftTemplateDto, _mshiftTemplate.Object);
// Assert
Assert.AreEqual(shiftTemplateDto.IsActive, _mshiftTemplate.Object.IsActive);
Assert.AreEqual(shiftTemplateDto.Name, _mshiftTemplate.Object.Name);
Assert.AreEqual(shiftTemplateDto.ShiftTypeId, _mshiftTemplate.Object.ShiftTypeId);
Assert.AreEqual(shiftTemplateDto.ResourceId, _mshiftTemplate.Object.ResourceId);
Assert.AreEqual(shiftTemplateDto.SiteId, _mshiftTemplate.Object.SiteId);
Assert.AreEqual(shiftTemplateDto.SubSiteId, _mshiftTemplate.Object.SubSiteId);
Assert.AreEqual(shiftTemplateDto.StartTime, _mshiftTemplate.Object.StartTime);
Assert.AreEqual(shiftTemplateDto.EndTime, _mshiftTemplate.Object.EndTime);
Assert.AreEqual(shiftTemplateDto.Duration, _mshiftTemplate.Object.Duration);
Assert.AreEqual(shiftTemplateDto.UnpaidBreakDuration, _mshiftTemplate.Object.UnpaidBreakDuration);
Assert.AreEqual(shiftTemplateDto.ShiftRate, _mshiftTemplate.Object.ShiftRate);
Assert.AreEqual(shiftTemplateDto.Mon, _mshiftTemplate.Object.Mon);
Assert.AreEqual(shiftTemplateDto.Tue, _mshiftTemplate.Object.Tue);
Assert.AreEqual(shiftTemplateDto.Wed, _mshiftTemplate.Object.Wed);
Assert.AreEqual(shiftTemplateDto.Thu, _mshiftTemplate.Object.Thu);
Assert.AreEqual(shiftTemplateDto.Fri, _mshiftTemplate.Object.Fri);
Assert.AreEqual(shiftTemplateDto.Sat, _mshiftTemplate.Object.Sat);
Assert.AreEqual(shiftTemplateDto.Sun, _mshiftTemplate.Object.Sun);
}
public List <ShiftProfileDto> GetInvalidShiftProfiles()
{
//var dataToReturn = new List<ShiftProfileDto>();
var shiftProfiles = _unitOfWork.ShiftProfileRepository
.Get(sp => sp.IsActive &&
sp.IsApproved == false &&
sp.Status != 0,
null,
"Shift, Shift.ShiftTemplate")
.OrderBy(sp => sp.StartDateTime);
if (shiftProfiles != null)
{
var shiftProfileDtos = new List <ShiftProfileDto>();
foreach (var shiftProfile in shiftProfiles)
{
var shiftProfileDto = Mapper.Map <ShiftProfileDto>(shiftProfile);
shiftProfileDto.TimeWorked = CommonHelperAppService.ReturnConvertedTicksAsTimespan(shiftProfileDto.HoursWorked);
shiftProfileDtos.Add(shiftProfileDto);
}
return(shiftProfileDtos);
}
//if (shiftProfiles != null)
//{
// var groupedShiftProfiles = shiftProfiles.GroupBy(sp => sp.ShiftId);
// foreach (var groupedShiftProfile in groupedShiftProfiles)
// {
// var shiftProfileDtos = new List<ShiftProfileDto>();
// foreach (var shiftProfile in groupedShiftProfile)
// {
// var shiftProfileDto = Mapper.Map<ShiftProfileDto>(shiftProfile);
// shiftProfileDto.TimeWorked = CommonHelperAppService.ReturnConvertedTicksAsTimespan(shiftProfileDto.HoursWorked);
// shiftProfileDtos.Add(shiftProfileDto);
// }
// dataToReturn.Add(shiftProfileDtos);
// }
// return dataToReturn;
//}
return(null);
}
public void Update(SitePersonnelLookupDto sitePersonnelLookupDto, long userId)
{
var sitePersonnelLookup = _unitOfWork.SitePersonnelLookupRepository.GetById(sitePersonnelLookupDto.Id);
CommonHelperAppService.MapDtoToEntityForUpdating(sitePersonnelLookupDto, sitePersonnelLookup);
_unitOfWork.SitePersonnelLookupRepository.Update(sitePersonnelLookup);
_unitOfWork.Save();
// Audit
_auditLogAppService.Audit(
AppConstants.ActionTypeUpdate,
AppConstants.SitePersonnelLookupTableName,
userId,
sitePersonnelLookup.Id);
}
public void Delete(long id, long userId)
{
var sitePersonnelLookup = _unitOfWork.SitePersonnelLookupRepository.GetById(id);
sitePersonnelLookup.IsActive = CommonHelperAppService.DeleteEntity();
_unitOfWork.SitePersonnelLookupRepository.Update(sitePersonnelLookup);
_unitOfWork.Save();
// Audit
_auditLogAppService.Audit(
AppConstants.ActionTypeDelete,
AppConstants.SitePersonnelLookupTableName,
userId,
sitePersonnelLookup.Id);
}
public void Delete(long id, long userId)
{
var subSite = _unitOfWork.SubSiteRepository.GetById(id);
subSite.IsActive = CommonHelperAppService.DeleteEntity();
_unitOfWork.SubSiteRepository.Update(subSite);
_unitOfWork.Save();
// Audit
_auditLogAppService.Audit(
AppConstants.ActionTypeDelete,
AppConstants.SubSiteTableName,
userId,
subSite.Id);
}
public void Delete(long id, long userId)
{
var user = _unitOfWork.UserRepository.GetById(id);
user.IsActive = CommonHelperAppService.DeleteEntity();
_unitOfWork.UserRepository.Update(user);
_unitOfWork.Save();
// Audit
_auditLogAppService.Audit(
AppConstants.ActionTypeDelete,
AppConstants.UserTableName,
userId,
user.Id);
}
public void Delete(long id, long userId)
{
var company = _unitOfWork.CompanyRepository.GetById(id);
company.IsActive = CommonHelperAppService.DeleteEntity();
_unitOfWork.CompanyRepository.Update(company);
_unitOfWork.Save();
// Audit
_auditLogAppService.Audit(
AppConstants.ActionTypeDelete,
AppConstants.CompanyTableName,
userId,
company.Id);
}
public void Update(SubSiteDto subSiteDto, long userId)
{
var subSite = _unitOfWork.SubSiteRepository.GetById(subSiteDto.Id);
CommonHelperAppService.MapDtoToEntityForUpdating(subSiteDto, subSite);
_unitOfWork.SubSiteRepository.Update(subSite);
_unitOfWork.Save();
// Audit
_auditLogAppService.Audit(
AppConstants.ActionTypeUpdate,
AppConstants.SubSiteTableName,
userId,
subSite.Id);
}
public void Update(CompanyDto companyDto, long userId)
{
var company = _unitOfWork.CompanyRepository.GetById(companyDto.Id);
CommonHelperAppService.MapDtoToEntityForUpdating(companyDto, company);
_unitOfWork.CompanyRepository.Update(company);
_unitOfWork.Save();
// Audit
_auditLogAppService.Audit(
AppConstants.ActionTypeUpdate,
AppConstants.CompanyTableName,
userId,
company.Id);
}
public void Update(EmployeeDto employeeDto, long userId)
{
var employee = _unitOfWork.EmployeeRepository.GetById(employeeDto.Id);
CommonHelperAppService.MapDtoToEntityForUpdating(employeeDto, employee);
_unitOfWork.EmployeeRepository.Update(employee);
_unitOfWork.Save();
// Audit
_auditLogAppService.Audit(
AppConstants.ActionTypeUpdate,
AppConstants.EmployeeTableName,
userId,
employee.Id);
}
public void Update(LeaveTypeDto leaveTypeDto, long userId)
{
var leaveType = _unitOfWork.LeaveTypeRepository.GetById(leaveTypeDto.Id);
CommonHelperAppService.MapDtoToEntityForUpdating(leaveTypeDto, leaveType);
_unitOfWork.LeaveTypeRepository.Update(leaveType);
_unitOfWork.Save();
// Audit
_auditLogAppService.Audit(
AppConstants.ActionTypeUpdate,
AppConstants.LeaveTypeTableName,
userId,
leaveType.Id);
}
public void Delete(long id, long userId)
{
var budgetPeriod = _unitOfWork.BudgetPeriodRepository.GetById(id);
budgetPeriod.IsActive = CommonHelperAppService.DeleteEntity();
_unitOfWork.BudgetPeriodRepository.Update(budgetPeriod);
_unitOfWork.Save();
// Audit
_auditLogAppService.Audit(
AppConstants.ActionTypeDelete,
AppConstants.BudgetPeriodTableName,
userId,
budgetPeriod.Id);
}
public void Update(BudgetPeriodDto budgetPeriodDto, long userId)
{
var budgetPeriod = _unitOfWork.BudgetPeriodRepository.GetById(budgetPeriodDto.Id);
CommonHelperAppService.MapDtoToEntityForUpdating(budgetPeriodDto, budgetPeriod);
_unitOfWork.BudgetPeriodRepository.Update(budgetPeriod);
_unitOfWork.Save();
// Audit
_auditLogAppService.Audit(
AppConstants.ActionTypeUpdate,
AppConstants.BudgetPeriodTableName,
userId,
budgetPeriod.Id);
}
