public async System.Threading.Tasks.Task AssignTask(AssignTaskInput2 input)
{
//C1:
var records = _task2Repository
.GetAll()
.Include(t => t.EmployeeTasks)
.FirstOrDefault(y => y.Id == input.Id);
records.EmployeeTasks.RemoveRange(0, records.EmployeeTasks.Count());
var a = records.EmployeeTasks;
await CurrentUnitOfWork.SaveChangesAsync();
foreach (var employeeId in input.EmployeeIds)
{
var employeeTask = new EmployeeTask();
employeeTask.Task2Id = input.Id;
employeeTask.EmployeeId = employeeId;
records.EmployeeTasks.Add(employeeTask);
}
await CurrentUnitOfWork.SaveChangesAsync();
//var task = GetTask(input.Id);
//C2:
//var output = ObjectMapper.Map<Task>(input);
//await _taskRepository.UpdateAsync(output);
}
public IActionResult Create(vmEmployeeTask vmEmployeeTask)
{
var loggedInEmployeeId = User.GetCurrentEmployeeId(db.Employee);
if (loggedInEmployeeId == vmEmployeeTask.AssignToId)
{
return(Json(false));
}
EmployeeTask task = new EmployeeTask()
{
AssigneeId = loggedInEmployeeId,
AssignToId = vmEmployeeTask.AssignToId,
Responsibility = vmEmployeeTask.Responsibility,
DueDate = vmEmployeeTask.ChangeDueDate != null ? vmEmployeeTask.DueDate: DateTime.Now,
Marks = vmEmployeeTask.Marks,
Comments = vmEmployeeTask.Comments,
};
db.EmployeeTask.Add(task);
db.Save();
if (task.Id > 0)
{
return(Json(true));
}
return(Json(false));
}
public override void Delete()
{
if (MessageBoxService.ShowMessage(string.Format(ScaffoldingLocalizer.GetString(ScaffoldingStringId.Confirmation_Delete), EntityDisplayName), GetConfirmationMessageTitle(), MessageButton.YesNo) != MessageResult.Yes)
{
return;
}
try {
if (Entity.AttachedFiles != null)
{
long[] deletedFileKeys = Entity.AttachedFiles.Select(x => x.Id).ToArray();
foreach (var key in deletedFileKeys)
{
var file = UnitOfWork.AttachedFiles.Find(key);
UnitOfWork.AttachedFiles.Remove(file);
}
}
OnBeforeEntityDeleted(PrimaryKey, Entity);
Repository.Remove(Entity);
UnitOfWork.SaveChanges();
long primaryKeyForMessage = PrimaryKey;
EmployeeTask entityForMessage = Entity;
Entity = null;
OnEntityDeleted(primaryKeyForMessage, entityForMessage);
Close();
} catch (DbException e) {
MessageBoxService.ShowMessage(e.ErrorMessage, e.ErrorCaption, MessageButton.OK, MessageIcon.Error);
}
}
private static string AddEmployeeTasks(TeisterMaskContext context, Employee employee, int[] tasks)
{
StringBuilder result = new StringBuilder();
foreach (var task in tasks)
{
if (IsTaskValid(context, task))
{
EmployeeTask employeeTask = new EmployeeTask
{
Employee = employee,
TaskId = task
};
context.EmployeesTasks.Add(employeeTask);
}
else
{
result.AppendLine(ErrorMessage);
}
}
context.SaveChanges();
return(result.ToString().TrimEnd());
}
public async Task <IActionResult> Post(EmployeeTask employee)
{
_unitOfWork.EmployeeTaskRepository.Add(employee);
await this._unitOfWork.SaveChangesAsync();
return(this.Ok(employee));
}
void Edit(EmployeeTask task)
{
if (ViewModel.CanEdit(task))
{
ViewModel.Edit(task);
}
}
void DoEditTask(EmployeeTask task)
{
if (ViewModel.EmployeeAssignedTasksLookUp.CanEdit(task))
{
ViewModel.EmployeeAssignedTasksLookUp.Edit(task);
}
}
public void sampleTest3()
{
var lines = File.ReadAllLines("../../sampleData4.txt");
EmployeeTask employees = new EmployeeTask(lines);
Assert.ThrowsException <Exception>(() => employees.calculateBudget("Employee4"));
}
public ActionResult DisplayCheckedTasks(int[] checkedRecords)
{
checkedRecords = checkedRecords ?? new int[] { };
List <TaskViewModel> data = GetTasks().Where(o => checkedRecords.Contains(o.TaskID)).ToList();
foreach (var tasks in data)
{
EmployeeTask empTask = new EmployeeTask();
empTask.EmployeeID = Convert.ToInt32(Session["Assignee"]);
empTask.TaskID = tasks.TaskID;
empTaskRepository.InsertOrUpdate(empTask);
empTaskRepository.Save();
}
//Update Employee record for task assignment
Employee emp = employeeRepository.Find(Convert.ToInt32(Session["Assignee"]));
emp.IsTaskAssigned = true;
emp.AssignmentCount = emp.AssignmentCount + data.Count;
employeeRepository.InsertOrUpdate(emp);
employeeRepository.Save();
//update Task record
foreach (var task in data)
{
Task _task = taskRepository.Find(task.TaskID);
_task.IsAssigned = true;
taskRepository.InsertOrUpdate(_task);
taskRepository.Save();
}
return(PartialView("CheckedTasks", data));
}
public EntityOperationResult addTask(EmployeeTaskDTO empTask)
{
EntityOperationResult ret = new EntityOperationResult();
try
{
var dbObj = new EmployeeTask();
dbObj.title = empTask.title;
dbObj.emp_id = empTask.emp_id;
dbObj.description = empTask.description;
dbObj.estimate = empTask.estimate;
dbObj.prioritylevel_id = empTask.prioritylevel_id;
dbObj.state_id = empTask.state_id;
dbContext.employeeTasks.Add(dbObj);
dbContext.SaveChanges();
ret.id = dbObj.emp_id;
ret.isSuccess = true;
ret.message = "Successfully Save";
}
catch (Exception ex)
{
ret.isSuccess = false;
ret.message = ex.Message;
}
return(ret);
}
public async Task <IActionResult> Edit(int id, [Bind("Id,TaskName,StartDate,Deadline")] EmployeeTask employeeTask)
{
if (id != employeeTask.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
await _employeeTaskService.EditEmpolyeeTask(employeeTask);
}
catch (DbUpdateConcurrencyException)
{
if (_employeeTaskService.GetEmployeeTaskById(employeeTask.Id) == null)
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(employeeTask));
}
public async Task <IActionResult> PutEmployeeTask(Guid id, EmployeeTask employeeTask)
{
if (id != employeeTask.Id)
{
return(BadRequest());
}
_context.Entry(employeeTask).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EmployeeTaskExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public bool UpdateEmployeeTask(EmployeeTask employeeTask)
{
using (var entities = new SFExpressEntities())
{
try
{
var toUpdate = entities.EmployeeTask.SingleOrDefault(x => x.EmployeeTaskID == employeeTask.EmployeeTaskID);
if (toUpdate != null)
{
entities.EmployeeTask.AddOrUpdate(employeeTask);
entities.SaveChanges();
return(true);
}
else
{
return(false);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
return(false);
}
}
}
public void EmployeeTaskAssignTest()
{
var newEmployeeTask = new EmployeeTask()
{
TaskName = "CRUDTestAssignment",
StartTime = DateTime.Now,
Deadline = DateTime.Now.AddDays(1)
};
EmployeeTaskController.Post(newEmployeeTask);
var newEmployee = new Employee()
{
FirstName = "UnitTest",
LastName = "Employee1",
HiredDate = DateTime.Now,
EmployeeTasks = string.Format(jsonFormat, newEmployeeTask.EmployeeTaskID)
};
EmployeeController.Post(newEmployee);
List <EmployeeViewModel> _allEmployee = EmployeeController.Get();
EmployeeViewModel toCompare = _allEmployee.Where(x => x.EmployeeID == newEmployee.EmployeeID).FirstOrDefault();
var assignedTask = JsonConvert.DeserializeObject <List <EmployeeTask> >(toCompare.EmployeeTasks).FirstOrDefault();
Assert.IsTrue(toCompare != null && newEmployeeTask.TaskName == assignedTask.TaskName);
EmployeeController.Delete(newEmployee.EmployeeID);
EmployeeTaskController.Delete(newEmployeeTask.EmployeeTaskID);
}
public static string ImportEmployees(TeisterMaskContext context, string jsonString)
{
var sb = new StringBuilder();
var employeeDtos = JsonConvert.DeserializeObject <List <ImportEmployeeDto> >(jsonString);
foreach (var employee in employeeDtos)
{
if (!IsValid(employee))
{
sb.AppendLine(ErrorMessage);
continue;
}
if (employee.Username.Any(ch => !char.IsLetterOrDigit(ch)))
{
sb.AppendLine(ErrorMessage);
continue;
}
var employeeToAdd = new Employee()
{
Username = employee.Username,
Email = employee.Email,
Phone = employee.Phone
};
foreach (var taskId in employee.Tasks.Distinct())
{
var task = context.Tasks
.FirstOrDefault(t => t.Id == taskId);
if (task == null)
{
sb.AppendLine(ErrorMessage);
continue;
}
var employeeTask = new EmployeeTask()
{
Employee = employeeToAdd,
Task = task
};
employeeToAdd.EmployeesTasks.Add(employeeTask);
}
context.Employees.Add(employeeToAdd);
context.SaveChanges();
sb.AppendLine(string.Format(SuccessfullyImportedEmployee, employeeToAdd.Username,
employeeToAdd.EmployeesTasks.Count));
}
return(sb.ToString().Trim());
}
public void EmployeeCRUDTest()
{
//create
var newEmployeeTask = new EmployeeTask()
{
TaskName = "CRUDTest",
StartTime = DateTime.Now,
Deadline = DateTime.Now.AddDays(1)
};
EmployeeTaskController.Post(newEmployeeTask);
List <EmployeeTask> _allEmployee = EmployeeTaskController.Get();
EmployeeTask toCompare = _allEmployee.Where(x => x.EmployeeTaskID == newEmployeeTask.EmployeeTaskID).FirstOrDefault();
Assert.IsTrue(toCompare != null && newEmployeeTask.TaskName == toCompare.TaskName);
//update
newEmployeeTask.TaskName = "UpdatedTask";
EmployeeTaskController.Put(newEmployeeTask);
_allEmployee = EmployeeTaskController.Get();
toCompare = _allEmployee.Where(x => x.EmployeeTaskID == newEmployeeTask.EmployeeTaskID).FirstOrDefault();
Assert.IsTrue(toCompare != null && newEmployeeTask.TaskName == toCompare.TaskName);
//delete
EmployeeTaskController.Delete(newEmployeeTask.EmployeeTaskID);
_allEmployee = EmployeeTaskController.Get();
Assert.IsTrue(!_allEmployee.Any(x => x.EmployeeTaskID == newEmployeeTask.EmployeeTaskID));
}
public async Task <ActionResult <EmployeeTask> > PostEmployeeTask([FromBody] EmployeeTask employeeTask)
{
_context.EmployeeTask.Add(employeeTask);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetEmployeeTask", new { id = employeeTask.Id }, employeeTask));
}
public static string ImportEmployees(TeisterMaskContext context, string jsonString)
{
var sb = new StringBuilder();
var employeesDtos = JsonConvert.DeserializeObject <ImportEmployeesDto[]>(jsonString);
foreach (var emplDto in employeesDtos)
{
if (!IsValid(emplDto))
{
sb.AppendLine(ErrorMessage);
continue;
}
var validEmployee = new Employee
{
Username = emplDto.Username,
Email = emplDto.Email,
Phone = emplDto.Phone
};
var validTasksIds = new List <int>();
var invalidTasksIds = new List <int>();
foreach (var taskId in emplDto.Tasks)
{
var currentTask = context.Tasks.FirstOrDefault(t => t.Id == taskId);
if (currentTask == null)
{
if (!invalidTasksIds.Contains(taskId))
{
sb.AppendLine(ErrorMessage);
invalidTasksIds.Add(taskId);
}
continue;
}
if (validTasksIds.Contains(taskId))
{
continue;
}
validTasksIds.Add(taskId);
var employeeTask = new EmployeeTask
{
Task = currentTask,
Employee = validEmployee
};
validEmployee.EmployeesTasks.Add(employeeTask);
}
context.Employees.Add(validEmployee);
sb.AppendLine($"Successfully imported employee - {validEmployee.Username} with {validEmployee.EmployeesTasks.Count} tasks.");
}
context.SaveChanges();
return(sb.ToString().Trim());
}
public static string ImportEmployees(TeisterMaskContext context, string jsonString)
{
var employeeDTOs = JsonConvert
.DeserializeObject <List <EmployeesImportModel> >(jsonString);
var result = new StringBuilder();
foreach (var employeeDTO in employeeDTOs)
{
if (!IsValid(employeeDTO))
{
result.AppendLine(ErrorMessage);
continue;
}
//unique tasks
var tasks = new List <Task>();
var employeeTasks = new List <EmployeeTask>();
var employee = new Employee()
{
Username = employeeDTO.Username,
Email = employeeDTO.Email,
Phone = employeeDTO.Phone
};
foreach (var taskId in employeeDTO.Tasks)
{
var task = context.Tasks.FirstOrDefault(t => t.Id == taskId);
if (task == null)
{
result.AppendLine(ErrorMessage);
continue; //TODO: what if all tasks are null?
}
if (!tasks.Contains(task))
{
tasks.Add(task);
var newEmployeeTask = new EmployeeTask()
{
Employee = employee,
Task = task
};
employeeTasks.Add(newEmployeeTask);
}
}
employee.EmployeesTasks = employeeTasks;
result.AppendLine(String.Format(SuccessfullyImportedEmployee,
employee.Username, employee.EmployeesTasks.Count));
context.Employees.Add(employee);
context.SaveChanges();
}
return(result.ToString().Trim());
}
public ActionResult DeleteConfirmed(int id)
{
EmployeeTask employeetask = db.EmployeeTasks.Single(e => e.Id == id);
db.EmployeeTasks.DeleteObject(employeetask);
db.SaveChanges();
return(RedirectToAction("Index"));
}
protected override EmployeeTask CreateEntity()
{
EmployeeTask entity = base.CreateEntity();
entity.StartDate = DateTime.Now;
entity.DueDate = DateTime.Now + new TimeSpan(48, 0, 0);
return(entity);
}
public async Task <ActionResult <EmployeeTask> > PostEmployeeTask(EmployeeTask employeeTask)
{
employeeTask.Id = Guid.NewGuid();
_context.EmployeeTasks.Add(employeeTask);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetEmployeeTask", new { id = employeeTask.Id }, employeeTask));
}
public ActionResult DeleteConfirmed(int id)
{
EmployeeTask employeeTask = db.EmployeeTasks.Find(id);
db.EmployeeTasks.Remove(employeeTask);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public static string ImportEmployees(TeisterMaskContext context, string jsonString)
{
var employeesImport = JsonConvert.DeserializeObject <List <ImportEmployeesDto> >(jsonString);
var allTasks = context.Tasks.Select(t => t.Id).ToList();
var employeeTasks = new List <EmployeeTask>();
var employees = new List <Employee>();
var sb = new StringBuilder();
foreach (var dto in employeesImport)
{
var isEmployeeValid = IsValid(dto);
if (!isEmployeeValid)
{
sb.AppendLine(ErrorMessage);
continue;
}
var employee = new Employee()
{
Username = dto.Username,
Phone = dto.Phone,
Email = dto.Email,
};
var tasksToLoop = dto.Tasks.Distinct();
foreach (var taskDto in tasksToLoop)
{
if (!allTasks.Contains(taskDto))
{
sb.AppendLine(ErrorMessage);
continue;
}
var employeeTask = new EmployeeTask()
{
Employee = employee,
TaskId = taskDto
};
employeeTasks.Add(employeeTask);
employee.EmployeesTasks.Add(employeeTask);
}
employees.Add(employee);
var result = string.Format(SuccessfullyImportedEmployee, employee.Username, employee.EmployeesTasks.Count);
sb.AppendLine(result);
}
context.Employees.AddRange(employees);
context.EmployeesTasks.AddRange(employeeTasks);
context.SaveChanges();
return(sb.ToString().TrimEnd());
}
public static string ImportEmployees(TeisterMaskContext context, string jsonString)
{
var dtos = JsonConvert.DeserializeObject <ImportEmployeesDto[]>(jsonString);
StringBuilder sb = new StringBuilder();
List <Employee> employees = new List <Employee>();
foreach (var dto in dtos)
{
if (!IsValid(dto))
{
sb.AppendLine(ErrorMessage);
continue;
}
Employee employee = new Employee
{
Username = dto.Username,
Phone = dto.Phone,
Email = dto.Email
};
var dtoTasksDistincted = dto.Tasks.Distinct();
foreach (var currentTask in dtoTasksDistincted)
{
bool isExist = context.Tasks.Any(x => x.Id == currentTask);
if (!isExist)
{
sb.AppendLine(ErrorMessage);
continue;
}
EmployeeTask employeeTask = new EmployeeTask
{
TaskId = currentTask
};
employee.EmployeesTasks.Add(employeeTask);
}
context.SaveChanges();
employees.Add(employee);
sb.AppendLine(string.Format(SuccessfullyImportedEmployee, employee.Username,
employee.EmployeesTasks.Count));
}
context.Employees.AddRange(employees);
context.SaveChanges();
return(sb.ToString().TrimEnd());
}
public static string ImportEmployees(TeisterMaskContext context, string jsonString)
{
var sb = new StringBuilder();
var employees = new List <Employee>();
var employeesTasksForImport = new List <EmployeeTask>();
var employeesDto = JsonConvert.DeserializeObject <EmployeeDto[]>(jsonString);
var tasksId = context.Tasks.Select(i => i.Id).ToList();
foreach (var dto in employeesDto)
{
if (!IsValid(dto))
{
sb.AppendLine(ErrorMessage);
continue;
}
if (!IsUsernameValid(dto.Username))
{
sb.AppendLine(ErrorMessage);
}
var employee = new Employee()
{
Username = dto.Username,
Email = dto.Email,
Phone = dto.Phone
};
var curentTasks = new List <EmployeeTask>();
foreach (var t in dto.Tasks.Distinct())
{
if (!tasksId.Contains(t))
{
sb.AppendLine(ErrorMessage);
continue;
}
var newEmployeeTask = new EmployeeTask
{
Employee = employee,
TaskId = t
};
curentTasks.Add(newEmployeeTask);
}
employeesTasksForImport.AddRange(curentTasks);
sb.AppendLine(string.Format(SuccessfullyImportedEmployee, employee.Username, curentTasks.Count));
}
context.Employees.AddRange(employees);
context.EmployeesTasks.AddRange(employeesTasksForImport);
context.SaveChanges();
return(sb.ToString().TrimEnd());
}
public void DeleteTask(EmployeeTask task)
{
if (task == null)
{
throw new ArgumentNullException(nameof(task));
}
_context.Tasks.Remove(task);
}
public async Task <EmployeeTask> InsertEmployeeTask(EmployeeTask data)
{
data.CreatedTS = DateTime.Now;
var result = await _context.EmployeeTasks.AddAsync(data);
await _context.SaveChangesAsync();
return(null);
}
public static string ImportEmployees(TeisterMaskContext context, string jsonString)
{
StringBuilder sb = new StringBuilder();
ImportEmployeeDto[] employeeDtos = JsonConvert.DeserializeObject <ImportEmployeeDto[]>(jsonString);
HashSet <Employee> validEmployees = new HashSet <Employee>();
foreach (ImportEmployeeDto employeeDto in employeeDtos)
{
if (!IsValid(employeeDtos))
{
sb.AppendLine(ErrorMessage);
continue;
}
Employee e = new Employee()
{
Username = employeeDto.Username,
Email = employeeDto.Email,
Phone = employeeDto.Phone
};
HashSet <EmployeeTask> employeeTasks = new HashSet <EmployeeTask>();
foreach (int taskId in employeeDto.Tasks.Distinct())
{
Task task = context
.Tasks
.Find(taskId);
if (task == null)
{
sb.AppendLine(ErrorMessage);
continue;
}
EmployeeTask employeeTask = new EmployeeTask()
{
Employee = e,
TaskId = taskId
};
employeeTasks.Add(employeeTask);
}
e.EmployeesTasks = employeeTasks;
validEmployees.Add(e);
sb.AppendLine(String.Format(SuccessfullyImportedEmployee, e.Username, employeeTasks.Count));
}
context.Employees.AddRange(validEmployees);
context.SaveChanges();
return(sb.ToString().TrimEnd());
}
void UpdateEditors(EmployeeTask task)
{
if (task == null)
{
return;
}
taskBindingSource.DataSource = task;
cbReminderDate.Enabled = cbReminderTime.Enabled = cbReminder.Checked;
}
