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