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); }