public ExcutionResult Delete(string id, string userId)
{
ExcutionResult rowAffected = new ExcutionResult();
try
{
var param = EmployeesManager.GetById(id);
if (param != null)
{
var now = DateTime.Now;
param.UpdatedAt = now;
param.UpdatedBy = userId;
rowAffected = EmployeesManager.Delete(param);
}
else
{
rowAffected.Message = "Id khong ton tai";
}
}
catch (Exception e)
{
rowAffected.ErrorCode = 1;
rowAffected.Message = e.Message;
_ilogger.LogError(e.Message, e);
}
return(rowAffected);
}
//Approve Employee's Application
public IActionResult EmployeeApprove(int id)
{
LogRestaurant();
ClaimsPrincipal cp = this.User;
var claims = cp.Claims.ToList();
var restId = Convert.ToInt32(claims.SingleOrDefault(p => p.Type == "RestaurantID").Value);
var userId = EmployeesManager.GetUserIdByEmployeeId(id);
var authId = UsersManager.GetAuthIdByUserId(userId);
var restaurantEmployee = RestaurantsManager.RestaurantByEmployeeId(restId, id);
restaurantEmployee.NewRequestFlag = false;
restaurantEmployee.Status = "Employee";
restaurantEmployee.RequestStatus = "Approved";
restaurantEmployee.Active = true;
RestaurantsManager.UpdateRestaurantEmployee(restaurantEmployee);
var authRestaurant = UsersManager.GetAuthenticationMatrixByIDs(restId, authId);
if (authRestaurant == null)
{
var authRest = new AuthenticationMatrix
{
RestaurantId = restId,
AuthenticationId = authId,
Role = "Employee"
};
UsersManager.AddOwnerToAuthetication(authRest);
}
else
{
authRestaurant.Role = "Employee";
UsersManager.UpdateAuthenticationMatrixByIDs(authRestaurant);
}
return(RedirectToAction("RestaurantEmployeesShow"));
}
public ExcutionResult Insert(Employees employees, string userId)
{
ExcutionResult rowAffected = new ExcutionResult();
try
{
var param = EmployeesManager.GetById(employees.id);
if (param == null)
{
var now = DateTime.Now;
employees.CreatedAt = now;
employees.CreatedBy = userId;
rowAffected = EmployeesManager.Insert(employees);
}
else
{
rowAffected.Message = "Id already exist";
}
}
catch (Exception e)
{
rowAffected.ErrorCode = 1;
rowAffected.Message = e.Message;
_ilogger.LogError(e.Message, e);
}
return(rowAffected);
}
public EmployeeViewModel(Employees employee, EmployeesManager employeesManager, string vmDisplayName)
{
_empManager = employeesManager;
_emp = employee;
base.DisplayName = vmDisplayName;
}
public ActionResult ShowEmployees(int?idCompany = null)
{
EmployeesFilter filter = new EmployeesFilter();
if (idCompany != null)
{
var result = CompanyManager.GetManager().LoadEntity(idCompany);
if (!result.Success)
{
return(HttpNotFound());
}
Session["Company"] = filter.Company = result.ResultEntity;
}
else
{
Session["Company"] = null;
}
Result <Employee> resultLoadList = EmployeesManager.GetManager().LoadEntityList(filter);
if (!resultLoadList.Success)
{
return(HttpNotFound());
}
;
return(View(resultLoadList.Entitys));
}
// GET: api/Employees
public async Task <IHttpActionResult> GetEmployees()
{
EmployeesManager employeesManager = new EmployeesManager();
EmployeesList = await employeesManager.LoadEmployees();
return(Ok(EmployeesList));
}
// GET: api/Employees/5
public async Task <IHttpActionResult> GetEmployees(int id)
{
EmployeesManager employeesManager = new EmployeesManager();
EmployeesList = await employeesManager.LoadEmployees();
return(Ok(EmployeesList.Where(x => x.id == id).ToList()));
}
public ActionResult EditEmployee(Employee employee)
{
EmployeesManager.GetManager().Save(employee);
//сессии использую для того, чтобы запоминать какая въюха была до перехода на форму редактирования
//(если мы перешли в редактирование пользователя из вьюхи со списком работников конкретной компании, то вернемся потом на эту же вьюху)
Company company = (Company)Session["Company"];
return(RedirectToAction("ShowEmployees", new { idCompany = (company != null) ? company.Id : null }));
}
// GET: Employees
//public ActionResult Index()
public async Task <ActionResult> Index()
{
ApiServices apiService = new ApiServices();
EmployeesManager employeesManager = new EmployeesManager();
EmployeesList = await employeesManager.getEmployees();
return(View(EmployeesList));
}
public AllEmployeesViewModel(EmployeesManager employeesManager, string displayName)
{
_empManager = employeesManager;
_empVmProvider = new EmployeeVmItemsProvider(_empManager);
DisplayName = displayName;
ValidateColumns();
GetAllEmployees();
AllEmployees.CollectionChanged += OnAllEmployeesCollectionChanged;
}
private void CreateNewEmployee()
{
var empItemsProvider = new ItemsProvider <Employees>(_context);
var empManager = new EmployeesManager(_context, empItemsProvider);
var employee = empManager.GetNewEmployee();
var vm = new EmployeeViewModel(employee, empManager, ViewModelNames.EmployeeViewModel_DisplayName);
Workspace.Add(vm);
SetActiveWorkspace(vm);
}
//Edit Employee's Edit
public IActionResult EmployeeEdit(int id)
{
LogRestaurant();
string role;
ClaimsPrincipal cp = this.User;
var claims = cp.Claims.ToList();
var restId = Convert.ToInt32(claims.SingleOrDefault(p => p.Type == "RestaurantID").Value);
var restaurantEmployee = RestaurantsManager.RestaurantByEmployeeId(restId, id);
var userId = EmployeesManager.GetUserIdByEmployeeId(restaurantEmployee.EmployeeId);
var authId = UsersManager.GetAuthIdByUserId(userId);
var authMatrix = UsersManager.GetAuthenticationMatrixByIDs(restId, authId);
if (authMatrix != null)
{
role = authMatrix.Role;
}
else
{
role = "";
}
var employeeUser = UsersManager.GetUserByUserId(userId);
string fullName = $"{employeeUser.FirstName} {employeeUser.LastName}";
var viewEmployee = new EmployeeModelView
{
RestaurantId = restaurantEmployee.RestaurantId,
EmployeeId = restaurantEmployee.EmployeeId,
UserId = employeeUser.UserId,
EmployeeFullName = fullName,
Active = restaurantEmployee.Active,
Status = restaurantEmployee.Status,
StartDate = (DateTime)restaurantEmployee.StartDate,
EndDate = restaurantEmployee.EndDate,
RequestFlag = restaurantEmployee.NewRequestFlag,
RequestStatus = restaurantEmployee.RequestStatus,
Role = role
};
ViewBag.EmployeeStatus = GetEmployeeStatus();
ViewBag.EmployeeRole = GetRestaurantRoles();
ViewBag.EmployeeStatusV = GetEmployeeStatusText(restaurantEmployee.Status);
if (GetRestaurantRolesValue(role) == "")
{
ViewBag.EmplyeeRoleV = "0";
}
else
{
ViewBag.EmplyeeRoleV = GetRestaurantRolesText(role);
}
return(View(viewEmployee));
}
public async Task <ActionResult> Index(string id)
{
if (id == "")
{
EmployeesManager employeesManager = new EmployeesManager();
EmployeesList = await employeesManager.getEmployees();
}
else
{
EmployeesManager employeesManager = new EmployeesManager();
EmployeesList = await employeesManager.getEmployees(int.Parse(id));
}
return(View(EmployeesList));
}
private void ShowAllEmployees()
{
var all = Workspace.FirstOrDefault(vm => vm is AllEmployeesViewModel) as AllEmployeesViewModel;
if (all == null)
{
var empItemsProvider = new ItemsProvider <Employees>(_context);
var empManager = new EmployeesManager(_context, empItemsProvider);
all = new AllEmployeesViewModel(empManager, ViewModelNames.AllEmployeesViewModel_DisplayName);
Workspace.Add(all);
}
SetActiveWorkspace(all);
}
public ExcutionResult GetAll()
{
ExcutionResult ex = new ExcutionResult();
try
{
var p = EmployeesManager.GetAll();
ex.Data = p;
}
catch (Exception e)
{
ex.ErrorCode = 1;
ex.Message = e.Message;
}
return(ex);
}
/// <summary>
/// Удаление работника
/// </summary>
/// <param name="idEmployee"></param>
/// <returns></returns>
public ActionResult DeleteEmployee(int idEmployee)
{
var result = EmployeesManager.GetManager().LoadEntity(idEmployee);
if (!result.Success)
{
return(HttpNotFound());
}
EmployeesManager.GetManager().Delete(result.ResultEntity);
//сессии использую для того, чтобы запоминать какая въюха была до перехода на форму редактирования
//(если мы перешли в редактирование пользователя из вьюхи со списком работников конкретной компании, то вернемся потом на эту же вьюху)
Company company = (Company)Session["Company"];
return(RedirectToAction("ShowEmployees", new { idCompany = (company != null) ? company.Id : null }));
}
private void btnCreateEmployees_Click(object sender, EventArgs e)
{
bsEmployees = new BindingSource();
EmployeesManager objEmployeesManager = new EmployeesManager();
bsEmployees.DataSource = objEmployeesManager.GetListofEmployees();
tbEmployeeID.DataBindings.Add("Text", bsEmployees, "EmployeeID");
tbHireDate.DataBindings.Add("Text", bsEmployees, "HireDate");
tbFullName.DataBindings.Add("Text", bsEmployees, "FullName");
pictureBox1.DataBindings.Add("Image", bsEmployees, "Photo", true, DataSourceUpdateMode.Never, new Bitmap(typeof(Button), "Button.bmp"));
bsEmployees.PositionChanged += new EventHandler(bsEmployees_PositionChanged);
bsEmployees_PositionChanged(this, null);
}
public ExcutionResult Search(string keyword)
{
ExcutionResult result = new ExcutionResult();
try
{
var param = EmployeesManager.Search(keyword);
result.Data = param;
}
catch (Exception e)
{
result.ErrorCode = 1;
result.Message = e.Message;
_ilogger.LogError(e.Message, e);
}
return(result);
}
public ExcutionResult GetAllByPaging(PagingItem pagingItem)
{
ExcutionResult ex = new ExcutionResult();
try
{
var p = EmployeesManager.GetAllByPaging(pagingItem);
ex.Data = p;
ex.MetaData = pagingItem;
}
catch (Exception e)
{
ex.ErrorCode = 1;
ex.Message = e.Message;
}
return(ex);
}
public async Task <IViewComponentResult> InvokeAsync(int id)
{
var restaurants = EmployeesManager.GetAllRestaurantsByEmpID(id);
var viewRestaurants = restaurants.Select(r => new EmployeeModelView
{
EmployeeId = r.EmployeeId,
Active = r.Active,
Status = r.Status,
Restaurant = r.Restaurant.RestaurantName,
RestaurantId = r.RestaurantId,
UserId = r.Employee.UserId,
StartDate = r.StartDate,
EndDate = r.EndDate,
RequestFlag = r.NewRequestFlag,
RequestStatus = r.RequestStatus
});
return(View(viewRestaurants));
}
public ActionResult EditEmployee(int?idEmployee = null)
{
//Эту штуку добавил для того, чтобы мы могли заполнить список имеющихся компаний на вьюхе
var result = CompanyManager.GetManager().LoadEntityList(null);
if (!result.Success)
{
return(HttpNotFound());
}
ViewData["Companys"] = from company in result.Entitys
select new SelectListItem {
Text = company.Name, Value = company.Id.ToString()
};
var resultLoadEntity = EmployeesManager.GetManager().LoadEntity((int)idEmployee);
if (!resultLoadEntity.Success)
{
return(View());
}
return(View(resultLoadEntity.ResultEntity));
}
public MainManager()
{
Database.SetInitializer(new MigrateDatabaseToLatestVersion <Context, Configuration>());
_departmentsManager = new DepartmentsManager {
SetWaiting = status => Waiting = status
};
_disciplinesManager = new DisciplinesManager {
SetWaiting = status => Waiting = status
};
_employeesManager = new EmployeesManager {
SetWaiting = status => Waiting = status
};
_facultiesManager = new FacultiesManager {
SetWaiting = status => Waiting = status
};
_groupsManager = new GroupsManager {
SetWaiting = status => Waiting = status
};
_specialitiesManager = new SpecialitiesManager {
SetWaiting = status => Waiting = status
};
_disciplineWorkloadManager = new DisciplineWorkloadManager {
SetWaiting = status => Waiting = status
};
_workloadManager = new WorkloadManager {
SetWaiting = status => Waiting = status
};
ShowSemestersDialog = new RelayCommand(OpenSettings);
ImportCommand = new RelayCommand(Import);
ExportCommand = new RelayCommand(Export);
ImportSettingsCommand = new RelayCommand(ImportSettings);
ExportSettingsCommand = new RelayCommand(ExportSettings);
ShowSpecialPositionsDialog = new RelayCommand(ShowSpecialPositions);
RefreshTabs();
}
public IActionResult EmployeeEdit(EmployeeModelView viewEmployee)
{
LogRestaurant();
string role;
var userId = EmployeesManager.GetUserIdByEmployeeId(viewEmployee.EmployeeId);
var authId = UsersManager.GetAuthIdByUserId(userId);
var restaurantEmployee = RestaurantsManager.RestaurantByEmployeeId(viewEmployee.RestaurantId, viewEmployee.EmployeeId);
var authMatrix = UsersManager.GetAuthenticationMatrixByIDs(viewEmployee.RestaurantId, authId);
viewEmployee.Status = GetEmployeeStatusValue(viewEmployee.Status);
viewEmployee.Role = GetRestaurantRolesValue(viewEmployee.Role);
if (restaurantEmployee.Active == false && viewEmployee.Active == true)
{
if (viewEmployee.Status == "Employee")
{
restaurantEmployee.RequestStatus = "Approved";
viewEmployee.EndDate = null;
if (authMatrix != null)
{
if (viewEmployee.Role == null)
{
authMatrix.Role = "Employee";
}
else
{
authMatrix.Role = viewEmployee.Role;
}
UsersManager.UpdateAuthenticationMatrixByIDs(authMatrix);
}
else
{
if (viewEmployee.Role == null)
{
role = "Employee";
}
else
{
role = viewEmployee.Role;
}
var newAuthMatrix = new AuthenticationMatrix
{
AuthenticationId = authId,
RestaurantId = viewEmployee.RestaurantId,
Role = role
};
UsersManager.AddEmployeeToAutheticationMatrix(newAuthMatrix);
}
}
}
else
{
if (restaurantEmployee.Active == true && viewEmployee.Active == false)
{
if (viewEmployee.Status == "Employee" || viewEmployee.Status == "Employee on Leave")
{
if (authMatrix == null)
{
var newAuthMatrix = new AuthenticationMatrix
{
AuthenticationId = authId,
RestaurantId = viewEmployee.RestaurantId,
};
}
authMatrix.Role = "Employee on Leave";
UsersManager.UpdateAuthenticationMatrixByIDs(authMatrix);
}
else
{
if (authMatrix != null)
{
UsersManager.DeleteAuthMatrixByIds(viewEmployee.RestaurantId, authId);
}
}
}
else
{
if (viewEmployee.Status != "Employee")
{
if (authMatrix != null)
{
UsersManager.DeleteAuthMatrixByIds(viewEmployee.RestaurantId, authId);
}
}
else
{
if (authMatrix == null)
{
var newAuthMatrix = new AuthenticationMatrix
{
AuthenticationId = authId,
RestaurantId = viewEmployee.RestaurantId,
};
}
authMatrix.Role = viewEmployee.Role;
UsersManager.UpdateAuthenticationMatrixByIDs(authMatrix);
}
}
}
restaurantEmployee.Status = viewEmployee.Status;
restaurantEmployee.EndDate = viewEmployee.EndDate;
restaurantEmployee.Active = viewEmployee.Active;
RestaurantsManager.UpdateRestaurantEmployee(restaurantEmployee);
return(RedirectToAction("RestaurantEmployeesShow"));
}
public async Task <IActionResult> LoginAsync(RestaurantLoginModelView authView)
{
TempData["RestaurantName"] = null;
if (authView.Type == 0)
{
var user = UsersManager.Authenticate(authView.Username, authView.Password);
if (user == null)
{
TempData["Message"] = null;
TempData["ErrorMessage"] = "Login Error!!!.Try Again. Don't forget to Register first!!";
return(RedirectToAction("Login", "Account"));
}
var custId = CustomersManager.GetCustomerIdByUserId(user.UserId);
var empId = EmployeesManager.GetEmployeeIdByUserId(user.UserId);
var ownId = OwnersManager.GetOwnerIdByUserId(user.UserId);
var claims = new List <Claim>()
{
new Claim(ClaimTypes.Name, user.Authentication.Username),
new Claim("FullName", $"{user.FirstName} {user.LastName}"),
new Claim("AuthID", user.AuthenticationId.ToString()),
new Claim("UserID", user.UserId.ToString()),
new Claim("CustomerID", custId.ToString()),
new Claim("EmployeeID", empId.ToString()),
new Claim("OwnerID", ownId.ToString()),
};
var claimsIdentity = new ClaimsIdentity(claims, "Cookies");
await HttpContext.SignInAsync("Cookies", new ClaimsPrincipal(claimsIdentity));
}
else
{
var user = RestaurantsManager.AuthenticateRestaurant(authView.Username, authView.Password, authView.RestaurantId);
if (user.UserId <= 0)
{
TempData["Message"] = null;
TempData["ErrorMessage"] = "Login Error!!!.Try Again.Don't forget to Register first!!";
return(RedirectToAction("Login", "Account"));
}
var custId = CustomersManager.GetCustomerIdByUserId(user.UserId);
var empId = EmployeesManager.GetEmployeeIdByUserId(user.UserId);
var ownId = OwnersManager.GetOwnerIdByUserId(user.UserId);
var claims = new List <Claim>()
{
new Claim(ClaimTypes.Name, user.Authentication.Username),
new Claim("FullName", $"{user.FirstName} {user.LastName}"),
new Claim("AuthID", user.AuthenticationId.ToString()),
new Claim("UserID", user.UserId.ToString()),
new Claim("CustomerID", custId.ToString()),
new Claim("EmployeeID", empId.ToString()),
new Claim("OwnerID", ownId.ToString()),
};
if (user.Authentication.AuthenticationMatrix.Count() > 0)
{
foreach (AuthenticationMatrix a in user.Authentication.AuthenticationMatrix)
{
if (a.RestaurantId == authView.RestaurantId)
{
claims.Add(new Claim("RestaurantID", a.RestaurantId.ToString()));
claims.Add(new Claim(ClaimTypes.Role, a.Role));
TempData["RestaurantName"] = RestaurantsManager.GetRestaurantIdByNameByRestauranID(a.RestaurantId);
}
}
}
var claimsIdentity = new ClaimsIdentity(claims, "Cookies");
await HttpContext.SignInAsync("Cookies", new ClaimsPrincipal(claimsIdentity));
}
if (TempData["returnUrl"] == null)
{
return(Redirect("~/Account/Profile"));
}
else
{
return(Redirect(TempData["returnUrl"].ToString()));
}
}
public IActionResult EmployeeApply(EmployeeModelView viewEmployee)
{
LogRestaurant();
bool newEmployee = false;
ClaimsPrincipal cp = this.User;
var claims = cp.Claims.ToList();
var userId = Convert.ToInt32(claims.SingleOrDefault(p => p.Type == "UserID").Value);
var empId = Convert.ToInt32(claims.SingleOrDefault(p => p.Type == "EmployeeID").Value);
if (empId == 0)
{
var employee = new Employees {
UserId = userId
};
EmployeesManager.CreateEmployee(employee);
empId = EmployeesManager.GetEmployeeIdByUserId(userId);
newEmployee = true;
}
var restaurants = RestaurantsManager.RestaurantsByEmployeeId(empId);
bool newRestaurant = true;
bool requestFlag = true;
string status;
string request;
foreach (RestaurantEmployees rest in restaurants)
{
if (viewEmployee.RestaurantId == rest.RestaurantId)
{
newRestaurant = false;
status = rest.Status;
request = rest.RequestStatus;
requestFlag = (bool)rest.NewRequestFlag;
}
}
if (newRestaurant)
{
var restaurantEmployee = new RestaurantEmployees
{
EmployeeId = empId,
RestaurantId = viewEmployee.RestaurantId,
RequestStatus = "on Hold",
NewRequestFlag = true,
Status = "Applicant",
Active = false,
};
RestaurantsManager.AddEmployeeToRestaurant(restaurantEmployee);
if (newEmployee)
{
TempData["Message"] = "You successfully applied for a position in a Restaurant. You need to Login again to upgrade your new credential!!";
TempData["ErrorMessage"] = null;
return(RedirectToAction("Logout", "Account"));
}
else
{
TempData["Message"] = "You successfully applied for a position in a Restaurant!!";
TempData["ErrorMessage"] = null;
return(RedirectToAction("Profile", "Account"));
}
}
else
{
TempData["Message"] = null;
TempData["ErrorMessage"] = "Sorry!! Your already applied to the Restaurant's position";
return(RedirectToAction("Profile", "Account"));
}
}
public EmployeeVmItemsProvider(EmployeesManager employeesManager)
{
_empManager = employeesManager;
}
