public async Task <IActionResult> Edit(int id, [Bind("EmployeeRoleId,Id,RoleId")] EmployeeRoles employeeRole)
{
if (id != employeeRole.EmployeeRoleId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(employeeRole);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EmployeeRoleExists(employeeRole.EmployeeRoleId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["Id"] = new SelectList(_context.AspNetUser, "Id", "Fullname", employeeRole.Id);
ViewData["RoleId"] = new SelectList(_context.RoleTypes, "RoleId", "RoleName", employeeRole.RoleId);
return(View(employeeRole));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Name,RoleLevel,CanAssignTask")] EmployeeRoles employeeRoles)
{
if (id != employeeRoles.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(employeeRoles);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EmployeeRolesExists(employeeRoles.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(employeeRoles));
}
/// <summary>
/// 添加员工
/// </summary>
/// <param name="emploYee"></param>
/// <returns></returns>
public int AddEmployee(Employee emploYee)
{
using (OracleConnection conn = DapperHelper.GetConnectionString())
{
conn.Open();
string sql1 = @"select EmployeeName from employee where EmployeeName=:EmployeeName";
var result1 = conn.Query <Employee>(sql1, emploYee);
int i = -1;
if (result1.Count() == 0)
{
string sql = @"insert into employee(employeename,employeepwd,empnickname,BlocId) values(:employeename,:employeepwd,:empnickname,:BlocId)";
int result = conn.Execute(sql, emploYee);
string sql2 = string.Format("select EmployeeID from Employee where EmployeeName=:EmployeeName");
var id = conn.Query <int>(sql2, emploYee).FirstOrDefault();
var employees = emploYee.RoleID.Split(',');
for (int j = 0; j < employees.Length; j++)
{
EmployeeRoles employeeRoles = new EmployeeRoles();
employeeRoles.EmployeeID = id;
employeeRoles.RoleID = Convert.ToInt32(employees[j]);
string sql3 = string.Format("insert into EmployeeRoles(EmployeeID,RoleID) values(:EmployeeID,:RoleID)");
var add = conn.Execute(sql3, employeeRoles);
}
return(result);
}
return(i);
}
}
public void AccessRightForEmployee()
{
AuthorizationManager objAuthMgr = new AuthorizationManager();
if ((!Rave.HR.BusinessLayer.Employee.Employee.CheckDepartmentHeadbyEmailId(objAuthMgr.getLoggedInUserEmailId())) && (!EmployeeRoles.CheckRolesEmployeeSummaryAndProfile()))
{
SpanEmpSummary.Visible = false;
}
if (!EmployeeRoles.CheckRolesEmployee())
{
SpanAddEmployee.Visible = false;
}
// Ishwar - NISRMS - 30102014 Start
string strUserIdentity = string.Empty;
strUserIdentity = HttpContext.Current.ApplicationInstance.Session["WindowsUsername"].ToString().Trim();
BusinessEntities.Employee Employee = new BusinessEntities.Employee();
Rave.HR.BusinessLayer.Employee.Employee employeeBL = new Rave.HR.BusinessLayer.Employee.Employee();
Employee = employeeBL.GetNISEmployeeList(strUserIdentity);
if (!String.IsNullOrEmpty(Employee.WindowsUserName))
{
if (Employee.WindowsUserName.ToUpper() == strUserIdentity.ToUpper())
{
//Employee Profile false for EDC team members
SpanEmployeeProfile.Visible = false;
}
}
else
{
string strNISUsers = string.Empty;
if (ConfigurationManager.AppSettings["NISReportsAccess"] != null)
{
strNISUsers = ConfigurationManager.AppSettings["NISReportsAccess"].ToString();
}
Common.AuthorizationManager.AuthorizationManager objAuth = new Common.AuthorizationManager.AuthorizationManager();
if (!strNISUsers.Contains(objAuth.getLoggedInUser()))
{
spanSkillSearchReport.Visible = false;
spanHeadCountReport.Visible = false;
spanSkillSearchReport.Visible = false;
spanSkillReport.Visible = false;
spanConsolidated.Visible = false;
spanConsolidatedByCostCode.Visible = false;
// Ishwar - NISRMS - 16022015 Start
spanMRFAgingReport.Visible = false;
spanMRFAgingForOpenPositionReport.Visible = false;
// Ishwar - NISRMS - 16022015 End
}
}
// Ishwar - NISRMS - 30102014 End
}
protected void popStaffList(EmployeeRoles role)
{
sqlController sqc = new sqlController();
lstStaff.DataSource = sqc.GetNamesInJob(role.ToString());
lstStaff.DataTextField = "Name";
lstStaff.DataValueField = "Name";
lstStaff.DataBind();
sqc = null;
}
private static EmployeeEntity BuildEmployee(
EmployeeRoles roles = EmployeeRoles.Executive, EmployeeEntity manager = null)
{
return(Builder <EmployeeEntity>
.CreateNew()
.With(x => x.Id = 0)
.And(x => x.Roles = roles)
.And(x => x.Manager = manager)
.Build());
}
public async Task <IActionResult> Create([Bind("Id,Name,RoleLevel,CanAssignTask")] EmployeeRoles employeeRoles)
{
if (ModelState.IsValid)
{
_context.Add(employeeRoles);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(employeeRoles));
}
private static IEnumerable<string> GetRoles(EmployeeRoles roles)
{
if ((roles & EmployeeRoles.Executive) == EmployeeRoles.Executive)
yield return EmployeeRoles.Executive.ToString();
if ((roles & EmployeeRoles.Manager) == EmployeeRoles.Manager)
yield return EmployeeRoles.Manager.ToString();
if ((roles & EmployeeRoles.Hr) == EmployeeRoles.Hr)
yield return EmployeeRoles.Hr.ToString();
}
public void UpdateEmployeeRoles_ByEmployeeId(int employeeId, int rolesId)
{
//do inserts
EmployeeRoles insert = new EmployeeRoles()
{
ResourceId = employeeId,
RolesId = rolesId,
};
_currentDbContext.EmployeeRoles.Add(insert);
_currentDbContext.SaveChanges();
}
public async Task <IActionResult> Create([Bind("EmployeeRoleId,Id,RoleId")] EmployeeRoles employeeRole)
{
if (ModelState.IsValid)
{
_context.Add(employeeRole);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["Id"] = new SelectList(_context.AspNetUser, "Id", "Fullname", employeeRole.Id);
ViewData["RoleId"] = new SelectList(_context.RoleTypes, "RoleId", "RoleName", employeeRole.RoleId);
return(View(employeeRole));
}
/// <summary>
/// Save data to employee role table
/// </summary>
/// <param name="employeeRoles"></param>
/// <returns></returns>
public async Task <SaveEmployeeRoleResponse> SaveAsync(EmployeeRoles employeeRoles)
{
try
{
await _employeeRoleRepository.AddAsync(employeeRoles);
await _unitOfWork.CompleteAsync();
return(new SaveEmployeeRoleResponse(employeeRoles));
}
catch (Exception ex)
{
// Do some logging stuff
return(new SaveEmployeeRoleResponse($"An error occurred when saving the EmployeeRoles: {ex.Message}"));
}
}
public async Task <IActionResult> PostAsync([FromBody] EmployeeRoles resource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
var result = await _employeeRoleService.SaveAsync(resource);
if (!result.Success)
{
return(BadRequest(result.Message));
}
return(Ok());
}
public async Task <IActionResult> PutAsync(int id, [FromBody] EmployeeRoles resource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
var result = await _employeeRoleService.UpdateAsync(id, resource);
if (result == null)
{
return(BadRequest(result));
}
var employeeResource = _mapper.Map <EmployeeRoles, EmployeeRoleResource>(result.EmployeeRole);
return(Ok());
}
private static IEnumerable <string> GetRoles(EmployeeRoles roles)
{
if ((roles & EmployeeRoles.Executive) == EmployeeRoles.Executive)
{
yield return(EmployeeRoles.Executive.ToString());
}
if ((roles & EmployeeRoles.Manager) == EmployeeRoles.Manager)
{
yield return(EmployeeRoles.Manager.ToString());
}
if ((roles & EmployeeRoles.Hr) == EmployeeRoles.Hr)
{
yield return(EmployeeRoles.Hr.ToString());
}
}
/*
* This method to add new Role to the Db with given Details
*/
public int AddRole(RolesDto toAddRole)
{
EmployeeRoles roleData = new EmployeeRoles();
try
{
roleData.RoleName = toAddRole.RoleName;
Context.EmployeeRoles.Add(roleData);
Context.SaveChanges();
}
catch (SqlException sqlExp)
{
throw sqlExp;
}
catch (NullReferenceException expNull)
{
throw expNull;
}
return(roleData.RoleId);
}
/// <summary>
/// 修改
/// </summary>
/// <param name="emploYee"></param>
/// <returns></returns>
public int UpdateEmployee(Employee emploYee)
{
using (OracleConnection conn = DapperHelper.GetConnectionString())
{
conn.Open();
string sql = @"update Employee set EmployeeName=:EmployeeName,EmployeePwd=:EmployeePwd,EmpNickName=:EmpNickName where EMPLOYEEID=:EMPLOYEEID";
int result = conn.Execute(sql, emploYee);
var employees = emploYee.RoleID.Split(',');
string sql1 = string.Format("delete from EmployeeRoles where EmployeeID=:EmployeeID");
var id = conn.Query <int>(sql1, new { EmployeeID = emploYee.EmployeeID });
for (int j = 0; j < employees.Length; j++)
{
EmployeeRoles employeeRoles = new EmployeeRoles();
employeeRoles.EmployeeID = emploYee.EmployeeID;
employeeRoles.RoleID = Convert.ToInt32(employees[j]);
string sql3 = string.Format("insert into EmployeeRoles(EmployeeID,RoleID) values(:EmployeeID,:RoleID)");
var add = conn.Execute(sql3, employeeRoles);
}
return(result);
}
}
public IHttpActionResult PostEmployeeRoles(dynamic obj)
{
int EmployeeID = obj.EmployeeID;
int RoleID = obj.RoleID;
var empCheck = principal.EmployeeRoles.Where(x => x.EmployeeID == EmployeeID && x.RoleID == RoleID).FirstOrDefault();
if (empCheck != null)
{
return(BadRequest());
}
var EmployeeRole = new EmployeeRoles
{
EmployeeID = EmployeeID,
RoleID = RoleID,
IsDeleted = false
};
principal.EmployeeRoles.Add(EmployeeRole);
principal.SaveChanges();
return(Ok());
}
public static bool IsIn(this Employee employee, EmployeeRoles roles)
{
return((employee.Roles & roles) == roles);
}
/// <summary>
/// Update data in the employee role table with user specified id
/// </summary>
/// <param name="id"></param>
/// <param name="employeeRoles"></param>
/// <returns></returns>
public async Task <SaveEmployeeRoleResponse> UpdateAsync(int id, EmployeeRoles employeeRoles)
{
var existingEmployeeRoles = await _employeeRoleRepository.FindByIdAsync(id);
if (existingEmployeeRoles == null)
{
return(new SaveEmployeeRoleResponse("Employee not found."));
}
existingEmployeeRoles.Department.dept_name = employeeRoles.Department.dept_name;
existingEmployeeRoles.Department.priority = employeeRoles.Department.priority;
existingEmployeeRoles.Department.phone_no = employeeRoles.Department.phone_no;
existingEmployeeRoles.Department.remark = employeeRoles.Department.remark;
existingEmployeeRoles.Role.Name = employeeRoles.Role.Name;
existingEmployeeRoles.Role.Priority = employeeRoles.Role.Priority;
existingEmployeeRoles.Role.Salary_range = employeeRoles.Role.Salary_range;
existingEmployeeRoles.start_date = employeeRoles.start_date;
existingEmployeeRoles.end_date = employeeRoles.end_date;
existingEmployeeRoles.remark = employeeRoles.remark;
existingEmployeeRoles.department_id = employeeRoles.department_id;
existingEmployeeRoles.employee_id = employeeRoles.employee_id;
existingEmployeeRoles.Employee.employeeId = existingEmployeeRoles.Employee.employeeId;
existingEmployeeRoles.Department.dept_id = employeeRoles.Department.dept_id;
existingEmployeeRoles.Department.branch_id = employeeRoles.Department.branch_id;
existingEmployeeRoles.Department.Branches.name = employeeRoles.Department.Branches.name;
existingEmployeeRoles.Department.Branches.phone_1 = employeeRoles.Department.Branches.phone_1;
existingEmployeeRoles.Department.Branches.phone_2 = employeeRoles.Department.Branches.phone_2;
existingEmployeeRoles.Department.Branches.Addresses.line_1 = employeeRoles.Department.Branches.Addresses.line_1;
existingEmployeeRoles.Department.Branches.Addresses.line_2 = employeeRoles.Department.Branches.Addresses.line_2;
existingEmployeeRoles.Department.Branches.Addresses.Township.Name = employeeRoles.Department.Branches.Addresses.Township.Name;
existingEmployeeRoles.Department.Branches.Addresses.Township.city.Name = employeeRoles.Department.Branches.Addresses.Township.city.Name;
existingEmployeeRoles.Department.Branches.Addresses.region = employeeRoles.Department.Branches.Addresses.region;
existingEmployeeRoles.Department.Branches.Addresses.country = employeeRoles.Department.Branches.Addresses.country;
existingEmployeeRoles.Employee.employee_No = employeeRoles.Employee.employee_No;
existingEmployeeRoles.Employee.employee_Name = employeeRoles.Employee.employee_Name;
existingEmployeeRoles.Employee.email = employeeRoles.Employee.email;
existingEmployeeRoles.Employee.dob = employeeRoles.Employee.dob;
existingEmployeeRoles.Employee.nrc = employeeRoles.Employee.nrc;
existingEmployeeRoles.Employee.phone_no_work = employeeRoles.Employee.phone_no_work;
existingEmployeeRoles.Employee.phone_no_personal = employeeRoles.Employee.phone_no_personal;
existingEmployeeRoles.Employee.gender = employeeRoles.Employee.gender;
existingEmployeeRoles.Employee.marital_status = employeeRoles.Employee.marital_status;
existingEmployeeRoles.Employee.nationality = employeeRoles.Employee.nationality;
existingEmployeeRoles.Employee.religion = employeeRoles.Employee.religion;
existingEmployeeRoles.Employee.permanent_address = employeeRoles.Employee.permanent_address;
existingEmployeeRoles.Employee.education_background = employeeRoles.Employee.education_background;
existingEmployeeRoles.Employee.joined_date = employeeRoles.Employee.joined_date;
existingEmployeeRoles.Employee.employee_state = employeeRoles.Employee.employee_state;
existingEmployeeRoles.Employee.Addresses.line_1 = employeeRoles.Employee.Addresses.line_1;
existingEmployeeRoles.Employee.Addresses.line_2 = employeeRoles.Employee.Addresses.line_2;
existingEmployeeRoles.Employee.Addresses.region = employeeRoles.Employee.Addresses.region;
existingEmployeeRoles.Employee.Addresses.country = employeeRoles.Employee.Addresses.country;
existingEmployeeRoles.rankId = employeeRoles.rankId;
existingEmployeeRoles.Ranks.Rank_Id = employeeRoles.Ranks.Rank_Id;
existingEmployeeRoles.Ranks.Name = employeeRoles.Ranks.Name;
try
{
_employeeRoleRepository.Update(existingEmployeeRoles);
await _unitOfWork.CompleteAsync();
return(new SaveEmployeeRoleResponse(existingEmployeeRoles));
}
catch (Exception ex)
{
// Do some logging stuff
return(new SaveEmployeeRoleResponse($"An error occurred when saving the EmployeeRole: {ex.Message}"));
}
}
private static EmployeeEntity BuildEmployee(
EmployeeRoles roles = EmployeeRoles.Executive, EmployeeEntity manager = null)
{
return Builder<EmployeeEntity>
.CreateNew()
.With(x => x.Id = 0)
.And(x => x.Roles = roles)
.And(x => x.Manager = manager)
.Build();
}
public void Remove(EmployeeRoles EmployeeRole)
{
_context.EmployeeRole.Remove(EmployeeRole);
}
public ActionResult Create(ResourcesViewModel appointmentResources, List <int> JobTypeIds, List <int> RolesList1, List <int> GroupsList1)
{
if (!caSession.AuthoriseSession())
{
return(Redirect((string)Session["ErrorUrl"]));
}
// get properties of current tenant
var tenant = caCurrent.CurrentTenant();
// get properties of user
caUser user = caCurrent.CurrentUser();
var wareh = _activityServices.GetAllPermittedWarehousesForUser(user.UserId, user.TenantId, user.SuperUser == true, false);
appointmentResources.TenantId = CurrentTenantId;
if (ModelState.IsValid)
{
//insert contactnumber
int contacNumbersId = _contactNumbersServices.Insert(Mapper.Map <ContactNumbers>(appointmentResources.ContactNumbers));
appointmentResources.ContactNumbersId = contacNumbersId;
//insert address
int addressId = _addressServices.Insert(Mapper.Map <Address>(appointmentResources.Address));
appointmentResources.AddressId = addressId;
//insert employee
appointmentResources.CreatedBy = user.UserId;
appointmentResources.UpdatedBy = user.UserId;
appointmentResources.DateCreated = DateTime.UtcNow;
appointmentResources.DateUpdated = DateTime.UtcNow;
appointmentResources.TenantId = tenant.TenantId;
int employeeId = _employeeServices.InsertEmployee(Mapper.Map <Resources>(appointmentResources));
appointmentResources.ResourceId = employeeId;
//insert employeeShifts_Store
if (appointmentResources.StoresList != null)
{
foreach (var item in appointmentResources.StoresList)
{
var insert = new EmployeeShifts_Stores()
{
ResourceId = employeeId,
WarehouseId = item,
};
_employeeShiftsStoresServices.Insert(insert);
}
}
//insert employeeRoles
if (RolesList1 != null)
{
foreach (var item in RolesList1)
{
if (item != 0)
{
var insert = new EmployeeRoles()
{
ResourceId = employeeId,
RolesId = item,
TenantId = tenant.TenantId,
DateCreated = DateTime.UtcNow,
DateUpdated = DateTime.UtcNow,
CreatedBy = user.UserId,
UpdatedBy = user.UserId
};
_employeeRolesServices.Insert(insert);
}
}
}
//insert employeeGroups
if (GroupsList1 != null)
{
foreach (var item in GroupsList1)
{
if (item != 0)
{
var insert = new EmployeeGroups()
{
ResourceId = employeeId,
GroupsId = item,
TenantId = tenant.TenantId,
DateCreated = DateTime.UtcNow,
DateUpdated = DateTime.UtcNow,
CreatedBy = user.UserId,
UpdatedBy = user.UserId
};
_employeeGroupsServices.Insert(insert);
}
}
}
// insert JobType Ids
_employeeServices.AddResourceJobTypes(Mapper.Map <Resources>(appointmentResources), JobTypeIds);
ViewBag.Success = $"Successfully Added";
return(RedirectToAction("Index"));
}
// viewbag data
var jTypes = LookupServices.GetAllJobTypes(CurrentTenantId).Select(m => new { m.JobTypeId, m.Name }).ToList();
ViewBag.JobTypes = new MultiSelectList(jTypes, "JobTypeId", "Name");
ViewBag.RolesList1 = new SelectList(_rolesServices.GetAllRoles(tenant.TenantId), "Id", "RoleName");
ViewBag.GroupsList1 = new SelectList(_groupsServices.GetAllGroups(tenant.TenantId), "Id", "GroupName");
ViewBag.Countries = new SelectList(LookupServices.GetAllGlobalCountries(), "CountryID", "CountryName");
ViewBag.TenantLocations = new MultiSelectList(_tenantLocationsServices.GetAllTenantLocations(tenant.TenantId).Where(x => wareh.Any(a => a.WId == x.WarehouseId)), "WarehouseId", "WarehouseName");
ViewBag.Users = new SelectList(_userService.GetAllAuthUsers(CurrentTenantId), "UserId", "UserName");
ViewBag.Warning = $"There is some problem with entereis, please check and try to save again";
return(View(appointmentResources));
}
private SaveEmployeeRoleResponse(bool success, string message, EmployeeRoles employeeRole) : base(success, message)
{
EmployeeRole = employeeRole;
}
public static bool IsIn(this Employee employee, EmployeeRoles roles)
{
return (employee.Roles & roles) == roles;
}
/// <summary>
/// Creates a success response.
/// </summary>
/// <param name="EmployeeRole">Saved EmplpoyeeRole.</param>
/// <returns>Response.</returns>
public SaveEmployeeRoleResponse(EmployeeRoles employeeRole) : this(true, string.Empty, employeeRole)
{
EmployeeRole = employeeRole;
}
//Занесение данных из _roles в контролы
public void Build(Hotel hotel)
{
_hotel = hotel;
_roles = _hotel.EmployeeRoles;
FillTable();
}
public async Task AddAsync(EmployeeRoles EmployeeRole)
{
await _context.EmployeeRole.AddAsync(EmployeeRole);
}
public IHttpActionResult PostCinemasAndDirectors(CinemaDirectorComplex cinemaDirectorComplex)
{
var employeeInfo = cinemaDirectorComplex.employeeInfo;
var cinemaInfo = cinemaDirectorComplex.cinemaInfo;
var employeeSamePhoneNumber = principal.Employees.Where(x => x.PhoneNumber == employeeInfo.PhoneNumber && !x.IsDeleted).FirstOrDefault();
if (employeeSamePhoneNumber != null)
{
return(Content(HttpStatusCode.BadRequest, ExceptionsMapper[ExceptionType.PhoneUniquenessViolation]));
}
var employeeSameEmail = principal.Employees.Where(x => x.Email == employeeInfo.Email && !x.IsDeleted).FirstOrDefault();
if (employeeSameEmail != null)
{
return(Content(HttpStatusCode.BadRequest, ExceptionsMapper[ExceptionType.EmailUniquenessViolation]));
}
//There is no need to check for usernames, since usernames are only restricted to one cinema.
//Username uniqueness only exists on a level of a cinema
//Since we are adding a new cinema and director, there are no employees which are related to it
//So there is no need to check for username uniqueness
Cinemas cinema = new Cinemas();
cinema.Name = cinemaInfo.Name;
cinema.CityID = cinemaInfo.CityID;
cinema.Address = cinemaInfo.Address;
cinema.IsDeleted = false;
principal.Cinemas.Add(cinema);
principal.SaveChanges();
Employees EMP = new Employees();
EMP.FirstName = employeeInfo.FirstName;
EMP.LastName = employeeInfo.LastName;
EMP.CityBirthID = employeeInfo.CityBirthID;
EMP.BirthDate = employeeInfo.BirthDate;
EMP.Gender = employeeInfo.Gender;
EMP.CurriculumVitae = employeeInfo.CurriculumVitae;
EMP.Email = employeeInfo.Email;
EMP.PhoneNumber = employeeInfo.PhoneNumber;
EMP.IsDeleted = false;
EMP.CinemaID = cinema.CinemaID;
EMP.Username = employeeInfo.Username;
EMP.PasswordSalt = employeeInfo.PasswordSalt;
EMP.PasswordHash = employeeInfo.PasswordHash;
principal.Employees.Add(EMP);
principal.SaveChanges();
int RoleID = principal.Roles.Where(x => x.Name == "Director").FirstOrDefault().RoleID;
EmployeeRoles employeeRoles = new EmployeeRoles
{
EmployeeID = EMP.EmployeeID,
RoleID = RoleID,
IsDeleted = false
};
principal.EmployeeRoles.Add(employeeRoles);
principal.SaveChanges();
return(Ok(new { CinemaID = cinema.CinemaID, EmployeeID = EMP.EmployeeID, RoleID = employeeRoles.RoleID }));
}
public ActionResult Edit(ResourcesViewModel appointmentResources, List <int> JobTypeIds, List <int> RolesList1, List <int> GroupsList1)
{
// get properties of current tenant
var tenant = caCurrent.CurrentTenant();
// get properties of user
caUser user = caCurrent.CurrentUser();
var wareh = _activityServices.GetAllPermittedWarehousesForUser(user.UserId, user.TenantId, user.SuperUser == true, false);
if (ModelState.IsValid)
{
appointmentResources.TenantId = CurrentTenantId;
//update
Resources newEmployee = _employeeServices.GetByEmployeeId(appointmentResources.ResourceId);
newEmployee.HolidayEntitlement = appointmentResources.HolidayEntitlement;
newEmployee.HourlyRate = appointmentResources.HourlyRate;
newEmployee.PersonTitle = appointmentResources.PersonTitle;
newEmployee.FirstName = appointmentResources.FirstName;
newEmployee.MiddleName = appointmentResources.MiddleName;
newEmployee.SurName = appointmentResources.SurName;
newEmployee.LikeToBeKnownAs = appointmentResources.LikeToBeKnownAs;
newEmployee.Gender = appointmentResources.Gender;
newEmployee.Married = appointmentResources.Married;
newEmployee.Nationality = appointmentResources.Nationality;
newEmployee.Color = appointmentResources.Color;
newEmployee.IsActive = appointmentResources.IsActive;
newEmployee.InternalStaff = appointmentResources.InternalStaff;
newEmployee.Nationality = appointmentResources.Nationality;
newEmployee.PayrollEmployeeNo = appointmentResources.PayrollEmployeeNo;
newEmployee.AuthUserId = appointmentResources.AuthUserId;
newEmployee.JobStartDate = appointmentResources.JobStartDate;
// update address
if (newEmployee.Address == null)
{
Address newAddress = new Address();
newAddress.AddressLine1 = appointmentResources.Address.AddressLine1;
newAddress.AddressLine2 = appointmentResources.Address.AddressLine2;
newAddress.AddressLine3 = appointmentResources.Address.AddressLine3;
newAddress.CountryID = appointmentResources.Address.CountryID;
newAddress.County = appointmentResources.Address.County;
newAddress.HouseNumber = appointmentResources.Address.HouseNumber;
newAddress.PostCode = appointmentResources.Address.PostCode;
newAddress.Town = appointmentResources.Address.Town;
int addressId = _addressServices.Insert(Mapper.Map <Address>(appointmentResources.Address));
newEmployee.AddressId = addressId;
}
else
{
newEmployee.Address.AddressLine1 = appointmentResources.Address.AddressLine1;
newEmployee.Address.AddressLine2 = appointmentResources.Address.AddressLine2;
newEmployee.Address.AddressLine3 = appointmentResources.Address.AddressLine3;
newEmployee.Address.CountryID = appointmentResources.Address.CountryID;
newEmployee.Address.County = appointmentResources.Address.County;
newEmployee.Address.HouseNumber = appointmentResources.Address.HouseNumber;
newEmployee.Address.PostCode = appointmentResources.Address.PostCode;
newEmployee.Address.Town = appointmentResources.Address.Town;
}
if (newEmployee.ContactNumbers == null)
{
//insert contactnumber
int contacNumbersId = _contactNumbersServices.Insert(Mapper.Map <ContactNumbers>(appointmentResources.ContactNumbers));
newEmployee.ContactNumbersId = contacNumbersId;
}
else
{
// update contacts
newEmployee.ContactNumbers.HomeNumber = appointmentResources.ContactNumbers.HomeNumber;
newEmployee.ContactNumbers.MobileNumber = appointmentResources.ContactNumbers.MobileNumber;
newEmployee.ContactNumbers.WorkNumber = appointmentResources.ContactNumbers.WorkNumber;
newEmployee.ContactNumbers.Fax = appointmentResources.ContactNumbers.Fax;
newEmployee.ContactNumbers.EmailAddress = appointmentResources.ContactNumbers.EmailAddress;
}
newEmployee.UpdatedBy = user.UserId;
newEmployee.DateUpdated = DateTime.UtcNow;
_employeeServices.UpdateEmployee(newEmployee);
//delete first EmployeeShifts_Store
_employeeShiftsStoresServices.DeleteEmployeeShiftsStoresByEmployeeId(appointmentResources.ResourceId);
//update EmployeeShifts_Store
if (appointmentResources.StoresList != null)
{
foreach (var item in appointmentResources.StoresList.ToList())
{
_employeeShiftsStoresServices.UpdateEmployeeShifts_StoresByEmployeeId(appointmentResources.ResourceId, item);
}
}
//delete first EmployeeRoles
_employeeRolesServices.DeleteEmployeeRolesByEmployeeId(appointmentResources.ResourceId);
//update EmployeeRoles
if (RolesList1 != null)
{
foreach (var item in RolesList1)
{
if (item != 0) //0=Select a Role
{
EmployeeRoles newRole = new EmployeeRoles
{
RolesId = item,
ResourceId = appointmentResources.ResourceId,
TenantId = tenant.TenantId,
CreatedBy = user.UserId,
UpdatedBy = user.UserId,
DateCreated = DateTime.UtcNow,
DateUpdated = DateTime.UtcNow,
};
_employeeRolesServices.Insert(newRole);
}
}
}
//delete first EmployeeGroups
_employeeGroupsServices.DeleteEmployeeGroupsByEmployeeId(appointmentResources.ResourceId);
//update EmployeeGroups
if (GroupsList1 != null)
{
foreach (var item in GroupsList1)
{
if (item != 0) //0=Select a Group
{
EmployeeGroups newGroup = new EmployeeGroups()
{
GroupsId = item,
ResourceId = appointmentResources.ResourceId,
TenantId = tenant.TenantId,
CreatedBy = user.UserId,
UpdatedBy = user.UserId,
DateCreated = DateTime.UtcNow,
DateUpdated = DateTime.UtcNow
};
_employeeGroupsServices.Insert(newGroup);
}
}
}
_employeeServices.UpdateResourceJobTypes(Mapper.Map <Resources>(appointmentResources), JobTypeIds);
return(RedirectToAction("Index"));
}
var jTypes = LookupServices.GetAllJobTypes(CurrentTenantId).Select(m => new { m.JobTypeId, m.Name }).ToList();
ViewBag.JobTypes = new MultiSelectList(jTypes, "JobTypeId", "Name", _employeeServices.GetResourceJobTypeIds(appointmentResources.ResourceId));
ViewBag.RolesList1 = new SelectList(_rolesServices.GetAllRoles(tenant.TenantId), "Id", "RoleName", _rolesServices.GetAllRolesByResource(appointmentResources.ResourceId));
ViewBag.GroupsList1 = new SelectList(_groupsServices.GetAllGroups(tenant.TenantId), "Id", "GroupName", _groupsServices.GetResourceGroupIds(appointmentResources.ResourceId));
ViewBag.Countries = new SelectList(LookupServices.GetAllGlobalCountries(), "CountryID", "CountryName", appointmentResources.GlobalCountry.CountryID);
ViewBag.TenantLocations = new MultiSelectList(_tenantLocationsServices.GetAllTenantLocations(tenant.TenantId).Where(x => wareh.Any(a => a.WId == x.WarehouseId)), "WarehouseId", "WarehouseName",
_employeeShiftsStoresServices.GetEmployeeShifts_StoresByEmployeeId(appointmentResources.ResourceId).Select(p => p.WarehouseId));
return(View(appointmentResources));
}
public void Insert(EmployeeRoles employeeRoles)
{
_currentDbContext.EmployeeRoles.Add(employeeRoles);
_currentDbContext.SaveChanges();
}
public void Update(EmployeeRoles EmployeeRole)
{
_context.EmployeeRole.Update(EmployeeRole);
}
