public async Task <IActionResult> AddEmployee(AddEmployeeViewModel model, int?id)
{
if (id == null)
{
return(NotFound());
}
var office = await _datacontext.Offices.FindAsync(id);
if (ModelState.IsValid)
{
var user = await CreateEmployee(model);
if (user != null)
{
var employee = new Employee
{
User = user,
Office = office,
Skype = model.Skype,
Cargo = model.Cargo
};
_datacontext.Employees.Add(employee);
await _datacontext.SaveChangesAsync();
return(RedirectToAction($"EmployList/{model.Id}"));
}
ModelState.AddModelError(string.Empty, "User already exists");
}
return(View(model));
}
public async Task <bool> UpdateEmployeeAsync(Guid id, AddEmployeeViewModel changedEmployee)
{
var employee = await _context.Employees
.Where(x => x.Id == id)
.SingleOrDefaultAsync();
var user = await _userManager.FindByIdAsync(changedEmployee.UserId);
var editedBy = await _userManager.FindByIdAsync(changedEmployee.EditedBy);
if (employee != null)
{
employee.User = user;
employee.EmploymentDate = changedEmployee.EmploymentDate;
employee.ContractEndDate = changedEmployee.ContractEndDate;
employee.BaseMonthSalary = changedEmployee.BaseMonthSalary;
employee.UpdateDate = changedEmployee.UpdateDate;
employee.EditedBy = editedBy;
_context.Update(employee);
}
var saveResult = await _context.SaveChangesAsync();
return(saveResult == 1);
}
[HttpGet] // GET: Employee}
public ActionResult AddEmployee()
{
AddEmployeeViewModel model = new AddEmployeeViewModel();
model.Employees = _employeeService.GetEmployees();
return(View(model));
}
public IActionResult Add(AddEmployeeViewModel model)
{
if (ModelState.IsValid)
{
string uniqueFileName = null;
if (model.Photo != null)
{
string uploadsFolder = Path.Combine(hostingEnvironment.WebRootPath, "images");
uniqueFileName = Guid.NewGuid().ToString() + "_" + model.Photo.FileName;
string filePath = Path.Combine(uploadsFolder, uniqueFileName);
model.Photo.CopyTo(new FileStream(filePath, FileMode.Create));
}
Employee newEmployee = new Employee
{
Name = model.Name,
Gender = model.Gender,
Role = model.Role,
Email = model.Email,
Contact = model.Contact,
Office = model.Office,
ImagePath = uniqueFileName
};
_employeeRepository.Add(newEmployee);
return(RedirectToAction("details", new { id = newEmployee.Id }));
}
return(View());
}
public async Task <ActionResult> AddEmployee(AddEmployeeViewModel model)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = model.Email, Email = model.Email, FirstName = model.FirstName, LastName = model.LastName, PhoneNumber = model.PhoneNumber
};
var result = await UserManager.CreateAsync(user, model.Password);
var db = new ApplicationDbContext();
var roleStore = new RoleStore <IdentityRole>(db);
var roleManager = new RoleManager <IdentityRole>(roleStore);
var userStore = new UserStore <ApplicationUser>(db);
var userManager = new UserManager <ApplicationUser>(userStore);
userManager.AddToRole(user.Id, "Collector");
var newCollector = new Collectors();
newCollector.UserId = user.Id;
newCollector.ZipCode = model.ZipCode;
var result2 = db.Collectors.Add(newCollector);
db.SaveChanges();
if (result.Succeeded)
{
return(RedirectToAction("Index", "Manage", new { Message = ManageMessageId.AddEmployeeSuccess }));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <ActionResult <EmployeeViewModel> > AddNewEmployee([FromBody] AddEmployeeViewModel employeeInput)
{
var newEmployee = new Employee(employeeInput);
var addEmployeeResult = await _employeeRepository.Create(newEmployee);
return(Ok(new EmployeeViewModel(addEmployeeResult)));
}
public Employee AddAsync(AddEmployeeViewModel dto)
{
Employee emp;
dto.Position = dbManager.GetById <Position>(dto.PositionId);
if (dto.Id > 0)
{
emp = dbManager.GetById <Employee>(dto.Id);
if (IsNotTrueTableNumber(dto.TableNumber) <= 1)
{
emp.Create(dto);
}
}
else
{
emp = new Employee();
if (IsNotTrueTableNumber(dto.TableNumber) == 0)
{
emp.Create(dto);
dbManager.AddAsync(emp);
}
}
return(emp);
}
public ActionResult Add()
{
AddEmployeeViewModel addEmployeeViewModel = new AddEmployeeViewModel();
addEmployeeViewModel.Departments = _department.GetDepatDepartments().ToList();
return(View(addEmployeeViewModel));
}
public ActionResult Create(AddEmployeeViewModel viewModel)
{
try
{
using (SqlConnection conn = Connection)
{
conn.Open();
using (SqlCommand cmd = conn.CreateCommand())
{
//query to choose information you want to insert into employree
cmd.CommandText = @"INSERT INTO Employee
( FirstName, LastName, DepartmentId, IsSupervisor )
VALUES
( @firstName, @lastName, @departmentId, @issupervisor )";
cmd.Parameters.Add(new SqlParameter("@firstName", viewModel.Employee.FirstName));
cmd.Parameters.Add(new SqlParameter("@lastName", viewModel.Employee.LastName));
cmd.Parameters.Add(new SqlParameter("@departmentId", viewModel.Employee.DepartmentId));
cmd.Parameters.Add(new SqlParameter("@issupervisor", viewModel.Employee.IsSupervisor));
cmd.ExecuteNonQuery();
//doesnt work yet but is supposed to redirect you back to the index view
return(RedirectToAction(nameof(Index)));
}
}
}
catch
{
return(View());
}
}
public async Task <IActionResult> EditEmployee(AddEmployeeViewModel addEmployeeView)
{
try
{
HttpClient httpClient = _httpClientFactory.CreateClient("EmpMGMTClient");
httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", HttpContext.Session.GetString("token")?.ToString());
string strJson = JsonConvert.SerializeObject(addEmployeeView);
StringContent stringContent = new StringContent(strJson, Encoding.UTF8, "application/json");
HttpResponseMessage response = httpClient.PostAsync("api/Employees/Updatemployee", stringContent).Result;
if (!response.IsSuccessStatusCode)
{
return(StatusCode((int)response.StatusCode));
}
var jsonResult = response.Content.ReadAsStringAsync().Result;
var jsonResonse = JsonConvert.DeserializeObject <ReturnResult>(jsonResult);
if (jsonResonse.Succeeded)
{
return(RedirectToAction("Employees"));
}
return(View(addEmployeeView));
}
catch (Exception x)
{
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
public ActionResult Add()
{
// create model
AddEmployeeViewModel model = new AddEmployeeViewModel();
return(View());
}
public void AddEmployeeToDataSource()
{
AddEmployeeViewModel viewModel = new AddEmployeeViewModel(db.Object);
viewModel.SaveDelegateCommand.Execute(emp);
db.Verify(o => o.Add(emp));
}
public void LoadAddEmployeePage()
{
IWindowManager manager = new WindowManager();
AddEmployeeViewModel add = new AddEmployeeViewModel();
manager.ShowDialog(add, null, null);
}
public ActionResult Add(AddEmployeeViewModel addEmployeeViewModel)
{
addEmployeeViewModel.Employee.Avatar = new ArchiveFile();
if (addEmployeeViewModel.FileUpload != null && addEmployeeViewModel.FileUpload.ContentLength > 0 && addEmployeeViewModel.FileUpload.ContentType.Contains("image"))
{
//Get Content of image
MemoryStream target = new MemoryStream();
addEmployeeViewModel.FileUpload.InputStream.CopyTo(target);
addEmployeeViewModel.Employee.Avatar.Content = target.ToArray();
addEmployeeViewModel.Employee.Avatar.Name = addEmployeeViewModel.FileUpload.FileName;
addEmployeeViewModel.Employee.Avatar.ContentType = addEmployeeViewModel.FileUpload.ContentType;
}
if (!string.IsNullOrEmpty(addEmployeeViewModel.BirthDay))
{
addEmployeeViewModel.Employee.BirthDay = addEmployeeViewModel.BirthDay.toEnglishNumber().ToGeorgianDateTime();
}
EmployeeManager employeeManager = new EmployeeManager();
//Add posts and departments to employee
employeeManager.AddPostDepartment(addEmployeeViewModel.Employee, addEmployeeViewModel.SelectedDepartments, addEmployeeViewModel.SelectedPosts);
employeeManager.Add(addEmployeeViewModel.Employee);
employeeManager.saveChanges();
return(RedirectToAction("Index"));
}
/// <summary>
/// Adds an employee and all their details to the DB. Uses a view model combining the Employee model fields and 2 additional fields for username and password.
/// </summary>
/// <param name="employeeToAdd"></param>
/// <returns></returns>
public ActionResult AddEmployee(AddEmployeeViewModel employeeToAdd)
{
OleDbConnection conn = new OleDbConnection();
OleDbCommand command = new OleDbCommand("insert into Employees ([lastName], [firstName], [address], [phone], [role], [username], [password]) values (?, ?, ?, ?, ?, ?, ?);");
command.Parameters.Add("?", OleDbType.VarWChar).Value = employeeToAdd.Employee.LastName;
command.Parameters.Add("?", OleDbType.VarWChar).Value = employeeToAdd.Employee.FirstName;
command.Parameters.Add("?", OleDbType.VarWChar).Value = employeeToAdd.Employee.Address;
command.Parameters.Add("?", OleDbType.Integer).Value = employeeToAdd.Employee.Phone;
command.Parameters.Add("?", OleDbType.VarWChar).Value = employeeToAdd.Employee.Role.ToString();
command.Parameters.Add("?", OleDbType.VarWChar).Value = employeeToAdd.Username;
command.Parameters.Add("?", OleDbType.VarWChar).Value = employeeToAdd.Password;
try
{
conn.ConnectionString = HomeController.connectionString;
conn.Open();
command.Connection = conn;
command.ExecuteNonQuery();
}
catch (Exception e)
{
}
finally
{
conn.Close();
}
return(RedirectToAction("Index", "EmployeeDetails"));
}
public ActionResult Add()
{
AddEmployeeViewModel model = new AddEmployeeViewModel();
model.Departments = GetDepartmentSelectList();
return(View(model));
}
public async Task <ActionResult> RegisterSportClubEmployee(AddEmployeeViewModel model)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser
{
UserName = model.User.Email,
Email = model.User.Email,
Name = model.User.Name,
LastName = model.User.LastName,
BirthDay = model.User.BirthDay.Value.ToString("s"),
DNI = model.User.DNI,
StartingDate = DateTime.Now.ToString("s"),
};
//var user = model.User;
//user.UserName = user.Email;
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await UserManager.AddToRoleAsync(user.Id, model.Rol);
return(RedirectToAction("Index", "User"));
}
AddErrors(result);
}
model.Roles = new string[] { "Empleado", "Coordinador", "Administrator" };
// If we got this far, something failed, redisplay form
return(View("../User/AddEmployeeForm", model));
}
public void LoadModifyEmployeePage(EmployeeDTO employee)
{
IWindowManager manager = new WindowManager();
AddEmployeeViewModel modify = new AddEmployeeViewModel(employee);
manager.ShowDialog(modify, null, null);
Reload();
}
public AddEmployeeWindow()
{
InitializeComponent();
DataContext = new AddEmployeeViewModel
{
ConfirmAction = new System.Action(() => { DialogResult = true; })
};
}
public ActionResult NewEmployee()
{
var viewModel = new AddEmployeeViewModel()
{
Roles = new string[] { "Empleado", "Coordinador", "Administrator" }
};
return(View("AddEmployeeForm", viewModel));
}
public IPermEmployee GetEmployeeFromAddVM(AddEmployeeViewModel empVM)
{
return(new PermEmployee
{
HoursWorked = empVM.HoursWorked,
Name = empVM.Name,
PayRate = empVM.PayRate
});
}
public virtual Employee Create(AddEmployeeViewModel model)
{
Name = model.Name;
Lastname = model.Lastname;
Fathername = model.Fathername;
TableNumber = model.TableNumber;
Position = model.Position;
return(this);
}
public async Task <IActionResult> AddEmployee(AddEmployeeViewModel employee)
{
try
{
HttpClient httpClient = _httpClientFactory.CreateClient("EmpMGMTClient");
httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", HttpContext.Session.GetString("token")?.ToString());
string strJson = JsonConvert.SerializeObject(employee);
StringContent stringContent = new StringContent(strJson, Encoding.UTF8, "application/json");
HttpResponseMessage response = httpClient.PostAsync("api/Employees/AddEmployee", stringContent).Result;
if (!response.IsSuccessStatusCode && !((int)response.StatusCode == 400))
{
return(StatusCode((int)response.StatusCode));
}
var jsonResult = response.Content.ReadAsStringAsync().Result;
var jsonResonse = JsonConvert.DeserializeObject <ReturnResult>(jsonResult);
if (jsonResonse.Succeeded)
{
return(RedirectToAction("Employees"));
}
response = await httpClient.GetAsync("api/Dropdowns/GetAddEmployeeDropdowns");
if (!response.IsSuccessStatusCode)
{
return(StatusCode((int)response.StatusCode));
}
jsonResult = response.Content.ReadAsStringAsync().Result;
AddEmployeeDropdowns jsonResonseAddEmployeeDropdowns = JsonConvert.DeserializeObject <AddEmployeeDropdowns>(jsonResult);
HttpResponseMessage response1 = await httpClient.GetAsync("api/Roles/GetRoles");
string jsonData = response1.Content.ReadAsStringAsync().Result;
var roles = JsonConvert.DeserializeObject <List <RoleViewModel> >(jsonData);
//ViewBag.AddEmployeeDropdowns = jsonResonse;
employee.Deapartments = jsonResonseAddEmployeeDropdowns.Departments;
employee.Countries = jsonResonseAddEmployeeDropdowns.Countries;
employee.MaritialStatuses = jsonResonseAddEmployeeDropdowns.MaritialStatuses;
employee.Genders = jsonResonseAddEmployeeDropdowns.Genders;
employee.Nationalities = jsonResonseAddEmployeeDropdowns.Nationalities;
employee.Roles = roles;
return(View(employee));
}
catch (Exception x)
{
return(StatusCode(StatusCodes.Status500InternalServerError, x.Message));
}
}
public Employee AddEmployee(FleetServiceClient socket)
{
addEmployeeWindow = new AddEmployeeWindow();
addEmployeeViewModel = new AddEmployeeViewModel()
{
AddCommand = new RelayCommand(ExecuteAddCommand),
BusinessUnits = socket.GetAllBusinessUnits().ToList()
};
addEmployeeWindow.DataContext = addEmployeeViewModel;
return(addEmployeeWindow.ShowDialog() == true ? addEmployeeViewModel.Employee : null);
}
public AddEmployeeView(dhEmployee objTodisplay)
{
InitializeComponent();
MyViewModel = new AddEmployeeViewModel(objTodisplay);
// InitializeComponent();
this.GlobalObjEmployee = new dhEmployee();
this.GlobalObjEmployee = objTodisplay;
this.EmpInfo.DataContext = this.GlobalObjEmployee;
this.AccountInfo.DataContext = MyViewModel.EmployeeAccount;
}
// GET: Employee/Create
public async Task <ActionResult> Create()
{
var countries = await _uow.CountryRepository.GetAllCountries();
var viewModel = new AddEmployeeViewModel()
{
Countries = countries.ToList()
};
return(View(viewModel));
}
public ActionResult Add(AddEmployeeViewModel employee)
{
Mapper.CreateMap <AddEmployeeViewModel, Employee>()
.ForMember(dest => dest.PhoneNumber, opt => opt.MapFrom(src => src.Phone))
.ForMember(dest => dest.DateOfBirth, opt => opt.MapFrom(src => src.BirthDate));
Employee emp = Mapper.Map <AddEmployeeViewModel, Employee>(employee);
m_EmployeeDepartmentService.AddEmployee(emp);
return(RedirectToAction("Index"));
}
public static bool AddEmployee(AddEmployeeViewModel param)
{
bool result = true;
try
{
#region 參數
string sqlQuery = String.Empty;
DynamicParameters sqlparam = new DynamicParameters();
sqlparam.Add("Name", param.Name.Trim());
if (!String.IsNullOrWhiteSpace(param.EnName))
{
sqlparam.Add("EnName", param.EnName.Trim());
}
else
{
sqlparam.Add("EnName", null);
}
#endregion
#region SQL 語法
sqlQuery = @"
INSERT INTO Employee
(
Name
,EnName
,CreateBy
,CreateTime
)
VALUES
(
@Name
,@EnName
,'SYS'
,GETDATE()
)";
#endregion
#region SQL 查詢
using (SqlConnection conn = new SqlConnection(strConn))
{
conn.Execute(sqlQuery, sqlparam);
}
#endregion
}
catch (Exception ex)
{
result = false;
}
return(result);
}
public ActionResult Add()
{
AddEmployeeViewModel addEmployeeViewModel = new AddEmployeeViewModel {
PageId = "AddEmployee"
};
DepartmentManager departmentManager = new DepartmentManager();
PostManager postManager = new PostManager();
addEmployeeViewModel.Departments = departmentManager.Read(null);
addEmployeeViewModel.Posts = postManager.Read(null);
return(View(addEmployeeViewModel));
}
public ActionResult Add()
{
AddEmployeeViewModel model = new AddEmployeeViewModel();
model.Departments = (from department in DepartmentRepository.GetAll()
select new SelectListItem()
{
Text = department.DepartmentName,
Value = department.DepartmentId.ToString(),
}).ToList();
return(View(model));
}
