public string InsertNewEmployee(CompanyEmployee employee) { string result = string.Empty; try { employee.companyDepartment = departmentRepo.GetById(employee.CompanyDepartment_ID); if (DepartmentIsMaxed(employee)) { result = Messages.sDepartmentIsMax; } else { IncreaseCurrentEmployeesInNewDepartment(employee); employeeRepo.Add(employee); employeeRepo.Save(); result = "new Employee Saved"; } } catch (Exception ex) { result = string.Format("{0} {1}", ex.Message ?? string.Empty, ex.InnerException.Message ?? string.Empty); } return(result); }//todo
public bool RegisterAdmin(RegisterModel admin) { try { CompanyEmployee adminObject = new CompanyEmployee() { FirstName = admin.FirstName, LastName = admin.LastName, Email = admin.Email, Password = admin.Password, PhoneNumber = admin.PhoneNumber, Role = "Admin", CreatedDateTime = DateTime.UtcNow, ModifiedDateTime = null }; this.context.Employees.Add(adminObject); int result = this.context.SaveChanges(); if (result > 0) { return(true); } else { return(false); } } catch (Exception e) { throw e; } }
}//todo public string EditExistingEmployee(CompanyEmployee editedEmployee) { string result = string.Empty; editedEmployee.companyDepartment = GetNewDepartment(editedEmployee.CompanyDepartment_ID); CompanyEmployee oldEmployee = GetOldDataOfEditingEmployee(editedEmployee); oldEmployee.companyDepartment = GetOldDepartment(oldEmployee.CompanyDepartment_ID); if (!employeeStayedInSameDepartment(editedEmployee, oldEmployee)) { if (DepartmentIsMaxed(editedEmployee)) { result = Messages.sDepartmentIsMax; } else { result = UpdateEmployeeAndDepartmentCurrentEmployee(editedEmployee, oldEmployee); } } else { employeeRepo.Update(editedEmployee); employeeRepo.Save(); result = "updated employee and count of current employees in new and old department"; } return(result); }
public List <CompanyEmployee> GetAllCompanyEmployee() { var companyEmployees = new List <CompanyEmployee>(); using (var sqlConnection = new SqlConnection(ConnectionString.CName)) { var cmd = new SqlCommand("spGetAllCompanyEmployee", sqlConnection); cmd.CommandType = CommandType.StoredProcedure; sqlConnection.Open(); var sqlDataReader = cmd.ExecuteReader(); while (sqlDataReader.Read()) { var companyEmployee = new CompanyEmployee(); companyEmployee.Id = Convert.ToInt32(sqlDataReader["Id"]); companyEmployee.CompanyId = Convert.ToInt32(sqlDataReader["CompanyId"]); companyEmployee.EmployeeId = Convert.ToInt32(sqlDataReader["EmployeeId"]); companyEmployees.Add(companyEmployee); } sqlConnection.Close(); } return(companyEmployees); }
private static string InsertCompanyEmployee(CompanyEmployeeServices service) { CompanyDepartmentServices departmentService = new CompanyDepartmentServices(); List <CompanyDepartment> departments = departmentService.GetAllDepartments(); CompanyDepartment department = departments.Find(x => x.maxEmployees == 1); CompanyEmployee employee = new CompanyEmployee() { firstName = "John", lastName = "Black", birthDate = DateTime.Now, emailAddress = "*****@*****.**", CompanyDepartment_ID = department.ID, companyDepartment = department }; string result = service.InsertNewEmployee(employee); CompanyEmployee employee2 = new CompanyEmployee() { firstName = "George", lastName = "Blue", birthDate = DateTime.Now, emailAddress = "*****@*****.**", CompanyDepartment_ID = departments.Find(x => x.CurrentEmployees < x.maxEmployees).ID, companyDepartment = departments.Find(x => x.CurrentEmployees < x.maxEmployees) }; result = result + " " + service.InsertNewEmployee(employee2); return(result); }
public ManageEmployeeViewModel(CompanyEmployee employee, CompanyRights managerRights, bool isEmployeeManager) { CompanyInfo = new CompanyInfoViewModel(employee.Company); IsManager = isEmployeeManager; CitizenID = employee.CitizenID; CitizenName = employee.Citizen.Entity.Name; Avatar = new ImageViewModel(employee.Citizen.Entity.ImgUrl); MinimumHP = employee.MinHP; Salary = (double)employee.Salary; var countryID = employee.Company.Region.CountryID; var currency = Persistent.Countries .First(c => c.ID == countryID) .Currency; CurrencyImage = Images.GetCountryCurrency(currency).VM; ManagerRights = managerRights; var companyService = DependencyResolver.Current.GetService <ICompanyService>(); Skill = employee.Citizen.GetWorkSkill(employee.Company); }
private MethodResult payCashForWork(Company company, Citizen citizen, CompanyEmployee employee) { var currency = company.Region.Country.Currency; var transaction = new structs.Transaction() { Arg1 = "Job Salary", Arg2 = string.Format("{0} Paid {1}", company.Entity.Name, citizen.Entity.Name), DestinationEntityID = citizen.ID, SourceEntityID = company.ID, Money = new Money() { Amount = employee.TodaySalary.Value, Currency = currency }, TransactionType = TransactionTypeEnum.Salary }; var result = transactionService.MakeTransaction(transaction); if (result == enums.TransactionResult.NotEnoughMoney) { return(new MethodResult("Company does not have enough money")); } companyFinanceSummaryService.AddFinances(company, new SalaryCostFinance(employee.TodaySalary.Value, currency.ID)); return(MethodResult.Success); }
public bool EditEmployee(UpdateModel updatedEmployee, int EmpId) { try { CompanyEmployee employee = this.context.Employees.Where(x => x.EmployeeId == EmpId).FirstOrDefault(); if (employee != null) { employee.EmployeeId = EmpId; employee.FirstName = updatedEmployee.FirstName; employee.LastName = updatedEmployee.LastName; employee.PhoneNumber = updatedEmployee.PhoneNumber; employee.Password = updatedEmployee.Password; employee.ModifiedDateTime = DateTime.Now; int result = this.context.SaveChanges(); if (result > 0) { return(true); } else { return(false); } } return(false); } catch (Exception e) { throw e; } }
static void Main(string[] args) { XmlSerializer xs = new XmlSerializer(typeof(Company)); FileStream fs = new FileStream("sample_company.xml", FileMode.Open); Company co = (Company)xs.Deserialize(fs); fs.Close(); CompanyEmployee e = new CompanyEmployee(); e.DepartmentID = 12; e.EmployeeID = 100; e.Name = "Nagarjuna"; CompanyEmployee[] ceArr = new CompanyEmployee[1]; ceArr[0] = e; co.Employees = ceArr; FileStream fswrite = new FileStream("new_company.xml", FileMode.OpenOrCreate); xs.Serialize(fswrite, co); fswrite.Close(); ; }
public CompanyEmployee EmployCitizen(EmployCitizenParameters pars) { var company = companyRepository .Include(c => c.CompanyEmployees) .FirstOrDefault(c => c.ID == pars.CompanyID); CompanyEmployee employee = new CompanyEmployee() { CitizenID = pars.CitizenID, MinHP = pars.ContractOffer == null ? company.DefaultMinHP : pars.ContractOffer.MinHP, Salary = (decimal)pars.Salary, StartDay = GameHelper.CurrentDay }; if (pars.ContractOffer != null) { var contract = pars.ContractOffer; employee.JobContract = new JobContract() { Length = contract.Length, MinHP = contract.MinHP, MinSalary = contract.MinSalary, SigneeID = contract.SigneeID }; } company.CompanyEmployees.Add(employee); jobOfferService.TakeJobOffer(pars.JobOfferID); companyRepository.SaveChanges(); return(employee); }
public ActionResult Edit(EmployeeViewModel employeeViewModel) { try { var employee = new Employee { Id = employeeViewModel.Id, Name = employeeViewModel.Name, Surname = employeeViewModel.Surname, SecondName = employeeViewModel.SecondName, HiringDate = employeeViewModel.HiringDate, Position = employeeViewModel.Position, }; _employeeManager.UpdateEmployee(employee); var companyEmployeeId = _companyEmployeeManager.GetIdByByEmployeeId(employee.Id); var employeeCompany = new CompanyEmployee { Id = companyEmployeeId, EmployeeId = employee.Id, CompanyId = employeeViewModel.CompanyId, }; _companyEmployeeManager.UpdateCompanyEmployee(employeeCompany); return(RedirectToAction(nameof(Index))); } catch { return(View()); } }
public IActionResult AddEmployee(AddEmployeeToCompanyViewModel addEmployeeToCompanyViewModel) { if (ModelState.IsValid) { var employeeId = addEmployeeToCompanyViewModel.EmployeeId; var companyId = addEmployeeToCompanyViewModel.CompanyId; var existingItems = _companyEmployeeRepository.GetQueryable() .Where(cm => cm.EmployeeId == employeeId) .Where(cm => cm.CompanyId == companyId) .ToList(); if (existingItems.Count == 0) { var newCompanyEmployee = new CompanyEmployee { EmployeeId = employeeId, CompanyId = companyId }; _companyEmployeeRepository.Add(newCompanyEmployee); return(Redirect("/Companies/Details?id=" + companyId)); } else { return(Redirect("/Characters/Details?id=" + companyId)); } } else { return(View(addEmployeeToCompanyViewModel)); } }
public ActionResult Create(EmployeeViewModel employeeViewModel) { if (ModelState.IsValid) { // UNDONE: Необходимо использовать DTO модель var employee = new Employee { Name = employeeViewModel.Name, Surname = employeeViewModel.Surname, SecondName = employeeViewModel.SecondName, HiringDate = employeeViewModel.HiringDate, Position = employeeViewModel.Position, }; _employeeManager.AddEmployee(employee); var lastEmployeeId = _employeeManager.GetLastId(); var employeeCompany = new CompanyEmployee { EmployeeId = lastEmployeeId, CompanyId = employeeViewModel.CompanyId, }; _companyEmployeeManager.AddCompanyEmployee(employeeCompany); // UNDONE: Обработать потенциальную ошибку при операции с данными return(RedirectToAction(nameof(Index))); } return(View()); }
public static void Main() { //class Inheritance FullTimeEmployee FTE = new FullTimeEmployee(); FTE.FirstName = "Yuvi"; FTE.LastName = "cad"; FTE.YearlySalary = 30000; FTE.PrintFullName(); PartTimeEmployee PTE = new PartTimeEmployee(); PTE.FirstName = "Jack"; PTE.LastName = "Cloud"; PTE.HourlySalary = 300; PTE.PrintFullName(); //polymorphism CompanyEmployee[] employee = new CompanyEmployee[3]; employee[0] = new CompanyEmployee(); employee[1] = new CompanyFullTimeEmployee(); employee[2] = new CompanyPartTimeEmployee(); foreach (CompanyEmployee e in employee) { e.PrintEmployeeName(); } }
public bool RegisterEmployee(RegisterModel employee) { try { CompanyEmployee employeeObject = new CompanyEmployee() { FirstName = employee.FirstName, LastName = employee.LastName, Email = employee.Email, Password = employee.Password, PhoneNumber = employee.PhoneNumber, Role = "Employee", CreatedDateTime = DateTime.UtcNow, ModifiedDateTime = null }; this.context.Employees.Add(employeeObject); int result = this.context.SaveChanges(); if (result > 0) { return true; } else { return false; } } catch (Exception e) { throw e; } }
public async Task <IActionResult> Edit(int id, [Bind("Id,EmployeeId,CompanyId,JobTitle")] CompanyEmployee companyEmployee) { if (id != companyEmployee.Id) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(companyEmployee); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!CompanyEmployeeExists(companyEmployee.Id)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } ViewData["CompanyId"] = new SelectList(_context.Company, "Id", "Id", companyEmployee.CompanyId); ViewData["EmployeeId"] = new SelectList(_context.Employee, "Id", "Id", companyEmployee.EmployeeId); return(View(companyEmployee)); }
// GET: CompanyEmployee public ActionResult Index() { var newCompanyEmployee = new CompanyEmployee(); newCompanyEmployee.employees = db.EmployeeContext.ToList(); return(View(newCompanyEmployee)); }
public void InformAboutMinimumHPChange(CompanyEmployee employee) { var company = employee.Company; var msg = string.Format("Your Minimum HP in {0} changed to {1}", company.Entity.Name, employee.MinHP); warningService.AddWarning(employee.CitizenID, msg); }
public static JobTypeEnum GetJobType(this CompanyEmployee employee) { if (employee.JobContractID != null) { return(JobTypeEnum.Contracted); } return(JobTypeEnum.Normal); }
private void terminateContract(CompanyEmployee employee, JobContract contract) { contractRepository.Remove(contract.ID); employee.JobContractID = null; ConditionalSaveChanges(contractRepository); warningService.AddWarning(employee.CitizenID, "Your contract has ended."); }
public async Task <ActionResult> DeleteConfirmed(int id) { CompanyEmployee companyemployee = await db.CompanyEmployees.FindAsync(id); db.CompanyEmployees.Remove(companyemployee); await db.SaveChangesAsync(); return(RedirectToAction("Index")); }
// GET: CompanyEmployee public ActionResult Index() { var newCompanyEmployee = new CompanyEmployee(); newCompanyEmployee.employees = db.employees.Select(i => new Employee { id = i.id, address = i.address, jobtitle = i.jobtitle, name = i.name, number = i.number }).ToList(); return(View(newCompanyEmployee)); }
public void InformAboutSalaryChange(CompanyEmployee employee) { var company = employee.Company; var currencyID = company.Region.Country.CurrencyID; var currency = Persistent.Currencies.First(c => c.ID == currencyID); var msg = string.Format("Your salary in {0} changed to {1} {2}", company.Entity.Name, employee.Salary, currency.Symbol); warningService.AddWarning(employee.CitizenID, msg); }
private string UpdateEmployeeAndDepartmentCurrentEmployee(CompanyEmployee editedEmployee, CompanyEmployee oldEmployee) { IncreaseCurrentEmployeesInNewDepartment(editedEmployee); UpdateEmployee(editedEmployee); string result = "Updated employee and department"; DecreaseCurrentEmployeesInOldDepartment(oldEmployee); return(result); }
public ActionResult EditEmployees([Bind(Include = "CompanyEmployeeID,empName,position,pictureID")] CompanyEmployee companyEmployee) { if (ModelState.IsValid) { db.Entry(companyEmployee).State = EntityState.Modified; db.SaveChanges(); return(RedirectToAction("Index", "Company")); } return(View(companyEmployee)); }
public void InformatAboutCompanyAbusement(Company company, CompanyEmployee employee) { var employeeName = employee.Citizen.Entity.Name; string employeeMsg = string.Format("You have abused your contract in {0}. Company boss may fire you from any moment right now.", company.Entity.Name); string companyMsg = string.Format("{0} has abused your contract. You may fire him from now on", employeeName); warningService.AddWarning(employee.CitizenID, employeeMsg); warningService.AddWarning(company.ID, companyMsg); }
public void InformAboutEmployeeAbusement(Company company, CompanyEmployee employee) { var employeeName = employee.Citizen.Entity.Name; string employeeMsg = string.Format("{0} has abused your contract rights. You may from now on resign from your job.", company.Entity.Name); string companyMsg = string.Format("Company abused {0}'s contract. {0} may leave work from now in any moment.", employeeName); warningService.AddWarning(employee.CitizenID, employeeMsg); warningService.AddWarning(company.ID, companyMsg); }
public ManageContractEmployeeViewModel(CompanyEmployee employee, CompanyRights managerRights, bool isEmployeeManager) : base(employee, managerRights, isEmployeeManager) { var contract = employee.JobContract; RemainingLength = contract.Length; MinimumSalary = (double)contract.MinSalary; MinimumHPOnContract = contract.MinHP; SignedByName = contract.Entity.Name; AbusedCompanyRules = contract.AbusedByEmployee; }
public bool CanLeaveJob(CompanyEmployee employee) { if (employee.GetJobType() == JobTypeEnum.Contracted) { var contract = employee.JobContract; return(contract.AbusedByCompany); } return(true); }
public string DeleteEmployee(CompanyEmployee employee) { employee.companyDepartment = GetOldDepartment(employee.CompanyDepartment_ID); employee.companyDepartment.CurrentEmployees--; departmentRepo.Update(employee.companyDepartment); departmentRepo.Save(); employeeRepo.Delete(employee); employeeRepo.Save(); return("Deleted employee and current employe count decreased"); }