public static void AssignTaskUpdate(AssignTask assignTask)
{
using (var dc = new DB(true))
{
dc.StoredProcedures.AssignTaskUpdate(assignTask);
}
}
public ActionResult DeleteConfirmed(int id)
{
AssignTask assignTask = db.AssignTasks.Find(id);
db.AssignTasks.Remove(assignTask);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult Edit([Bind(Include = "TaskId,TaskName")] AssignTask assignTask)
{
if (ModelState.IsValid)
{
db.Entry(assignTask).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(assignTask));
}
public ActionResult Create([Bind(Include = "TaskId,TaskName")] AssignTask assignTask)
{
if (ModelState.IsValid)
{
db.AssignTasks.Add(assignTask);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(assignTask));
}
public BaseResponse <AssignTask> SaveAssignTask(AssignTask request)
{
if (request.Id == 0)
{
request.OrgId = SecurityHelper.CurrentPrincipal.OrgId;
}
request.RecStatus = false;
request.NewrecFlag = true;
request.AutoFlag = false;
return(base.Save <LTC_ASSIGNTASK, AssignTask>(request, (q) => q.ID == request.Id));
}
public IHttpActionResult Post(AssignTask baseRequest)
{
if (string.IsNullOrEmpty(baseRequest.Assignee))
{
baseRequest.Assignee = SecurityHelper.CurrentPrincipal.EmpNo;
}
if (string.IsNullOrEmpty(baseRequest.AssignName))
{
baseRequest.AssignName = SecurityHelper.CurrentPrincipal.EmpName;
}
var response = AssignTaskService.SaveAssignTask(baseRequest);
return(Ok(response));
}
// GET: AssignTasks/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
AssignTask assignTask = db.AssignTasks.Find(id);
if (assignTask == null)
{
return(HttpNotFound());
}
return(View(assignTask));
}
public void Test1()
{
var options = new DbContextOptionsBuilder <RestAPIContext>()
.UseInMemoryDatabase("testdb")
.Options;
var db = new RestAPIContext(options);
User u1 = new User {
UserId = 1, FirstName = "A", LastName = "B"
};
User u2 = new User {
UserId = 2, FirstName = "C", LastName = "D"
};
db.Users.Add(u1);
db.Users.Add(u2);
AssignTask t1 = new AssignTask {
Name = "T1", AssignTo = u1
};
AssignTask t2 = new AssignTask {
Name = "T2", AssignTo = u1
};
AssignTask t3 = new AssignTask {
Name = "T3", AssignTo = u1
};
AssignTask t4 = new AssignTask {
Name = "T4", AssignTo = u2
};
AssignTask t5 = new AssignTask {
Name = "T5", AssignTo = u2
};
db.AssignTasks.Add(t1);
db.AssignTasks.Add(t2);
db.AssignTasks.Add(t3);
db.AssignTasks.Add(t4);
db.AssignTasks.Add(t5);
db.SaveChanges();
var users = db.Users;
var u1AssignedTasks = db.Users.Include(x => x.AssignTasks).FirstOrDefault(x => x.UserId == 1);
var u2AssignedTasks = db.Users.Include(x => x.AssignTasks).FirstOrDefault(x => x.UserId == 2);
Assert.AreEqual(users.Count(), 2);
Assert.AreEqual(u1AssignedTasks.AssignTasks.Count(), 3);
Assert.AreEqual(u2AssignedTasks.AssignTasks.Count(), 2);
}
public BaseResponse <AssignTask> SaveAssignTask2(AssignTask2 request)
{
AssignTask ass = new AssignTask {
OrgId = SecurityHelper.CurrentPrincipal.OrgId,
PerformDate = request.NEXTEVALDATE,
Assignee = request.NEXTEVALUATEBY == null ? SecurityHelper.CurrentPrincipal.EmpNo : request.NEXTEVALUATEBY,
FeeNo = request.FEENO,
Content = AutoTaskTmp.AutoTask[request.KEY].Content,
RecStatus = false,
NewrecFlag = true,
AutoFlag = true,
AssignDate = DateTime.Now
};
return(base.Save <LTC_ASSIGNTASK, AssignTask>(ass, (q) => (false)));
}
public void AssignTaskInsert(AssignTask assignTask)
{
var cmd = _db.CreateCommand("AssignTasks_Insert", true);
_db.AddParameter(cmd, "TaskId", DbType.Int32, assignTask.TaskId);
_db.AddParameter(cmd, "UserId", DbType.Int32, assignTask.UserId);
_db.AddParameter(cmd, "Requirement", DbType.String, assignTask.Requirement);
_db.AddParameter(cmd, "CompletedPercent", DbType.Int32, assignTask.CompletedPercent);
_db.AddParameter(cmd, "StartDate", DbType.DateTime, assignTask.StartDate);
_db.AddParameter(cmd, "EndDate", DbType.DateTime, assignTask.EndDate);
_db.AddParameter(cmd, "CreateDate", DbType.DateTime, assignTask.CreateDate);
_db.AddParameter(cmd, "ModifyDate", DbType.DateTime, assignTask.ModifyDate);
_db.AddParameter(cmd, "CreateBy", DbType.Int32, assignTask.CreateBy);
_db.AddParameter(cmd, "ModifyBy", DbType.Int32, assignTask.ModifyBy);
cmd.ExecuteNonQuery();
}
public async Task <bool> EditTask(AssignTaskVM task)
{
var user = _db.Users.Find(task.UserId);
AssignTask assignTask = new AssignTask
{
TaskId = task.TaskId,
Name = task.Name,
Description = task.Description,
StartDate = task.StartDate,
EndDate = task.EndDate,
AssignTo = user
};
_db.Entry(assignTask).State = EntityState.Modified;
return(await _db.SaveChangesAsync() > 0);
}
public ActionResult Create(AssignTask assignTask)
{
var task = TaskBO.GetById(assignTask.TaskId);
if (task == null)
{
return(RedirectToAction("NotFound", "Home"));
}
assignTask.CreateBy = CurrentUser.Id;
assignTask.CreateDate = DateTime.Now;
assignTask.ModifyBy = CurrentUser.Id;
assignTask.ModifyDate = DateTime.Now;
if (!string.IsNullOrEmpty(assignTask.StartAndEndDate) && assignTask.StartAndEndDate.Split('-').Length == 2)
{
var strStart = assignTask.StartAndEndDate.Split('-')[0].Trim();
var strEnd = assignTask.StartAndEndDate.Split('-')[1].Trim();
DateTime sdate;
DateTime edate;
if (DateTime.TryParseExact(strStart, Helper.FormatDate,
new CultureInfo("en-US"),
DateTimeStyles.None,
out sdate))
{
assignTask.StartDate = sdate;
}
if (DateTime.TryParseExact(strEnd, Helper.FormatDate,
new CultureInfo("en-US"),
DateTimeStyles.None,
out edate))
{
assignTask.EndDate = edate;
}
TaskBO.AssignTaskInsert(assignTask);
AlertBO.Insert(assignTask.Requirement, (int)AlertType.AssignTask, 0, assignTask.UserId);
}
return(RedirectToAction("Index", new { id = assignTask.TaskId }));
ViewBag.Task = task;
ViewBag.Users = UserBO.GetByDepartmentId(CurrentUser.DepartmentLeader);
return(View(assignTask));
}
public ActionResult Create(int id)
{
var task = TaskBO.GetById(id);
if (task == null)
{
return(RedirectToAction("NotFound", "Home"));
}
var assignTask = new AssignTask
{
TaskId = id
};
ViewBag.Task = task;
ViewBag.Users = UserBO.GetByDepartmentId(CurrentUser.DepartmentLeader);
return(View(assignTask));
}
public async Task <AssignTaskVM> AddTask(AssignTaskVM task)
{
var user = _db.Users.Find(task.UserId);
AssignTask assignTask = new AssignTask
{
TaskId = 0,
Name = task.Name,
Description = task.Description,
StartDate = task.StartDate,
EndDate = task.EndDate,
AssignTo = user
};
_db.AssignTasks.Add(assignTask);
await _db.SaveChangesAsync();
task.TaskId = assignTask.TaskId;
return(task);
}
//Assigns task to a selected student
private void btnAssignTaskStudent_Click(object sender, EventArgs e)
{
if (string.IsNullOrEmpty(cbxTeacherAssignGroup.Text) || string.IsNullOrEmpty(cbxTeacherAssignTask.Text) || string.IsNullOrEmpty(chbxTeacherAssignStudetnList.Text))
{
MessageBox.Show("Please fill in all fields");
}
else
{
foreach (var item1 in chbxTeacherAssignStudetnList.CheckedItems)
{
foreach (var item2 in db.Students.ToList())
{
if (item2.StudentName == item1.ToString())
{
StudentId = item2.StudentId;
foreach (var item3 in db.Tasks.ToList())
{
if (item3.TaskName == cbxTeacherAssignTask.Text)
{
if (db.AssignTasks.Any(w => w.StudentId == StudentId && w.TaskId == item3.TaskId))
{
MessageBox.Show("This task has already been assigned to the student");
}
else
{
AssignTask assign = new AssignTask()
{
StudentId = StudentId,
TaskId = item3.TaskId,
GroupId = GroupId,
};
db.AssignTasks.Add(assign);
db.SaveChanges();
}
}
}
}
}
}
}
}
public IActionResult UpdateTask(AssignTask item)
{
if (HttpContext.Session.GetString("UserRole") == "1" && HttpContext.Session.GetString("UserRole") != "Expired")
{
AssignTask t = new AssignTask()
{
TaskId = item.TaskId,
TaskTitle = item.TaskTitle,
Description = item.Description,
Date = item.Date,
EmployeeId = item.EmployeeId
};
db.AssignTask.Update(t);
db.SaveChanges();
return(RedirectToAction("TaskList"));
}
else
{
return(RedirectToAction("Index", "Home"));
}
}
public IActionResult Search(int id)
{
if (HttpContext.Session.GetString("UserRole") == "1" ||
HttpContext.Session.GetString("UserRole") == "2" &&
HttpContext.Session.GetString("UserRole") != "Expired")
{
var item = db.AssignTask.AsNoTracking().Where(s => s.TaskId == id).FirstOrDefault();
AssignTask t = new AssignTask()
{
TaskId = item.TaskId,
TaskTitle = item.TaskTitle,
Description = item.Description,
Date = item.Date,
EmployeeId = item.EmployeeId
};
return(View(t));
}
else
{
return(RedirectToAction("Index", "Home"));
}
}
public BaseResponse ReAssignTask(AssignTask oldTask, IList <TaskEmpFile> empList)
{
BaseResponse response = new BaseResponse();
//var oldTask = GetAssignTask(id);
List <LTC_ASSIGNTASK> newTaskList = empList.Select(t => new LTC_ASSIGNTASK
{
ID = 0,
ASSIGNEDBY = SecurityHelper.CurrentPrincipal.EmpNo,
ASSIGNEE = t.EmpNo,
ASSIGNNAME = t.EmpName,
NEWRECFLAG = true,
ASSIGNDATE = DateTime.Now,
CONTENT = oldTask.Content,
FEENO = oldTask.FeeNo,
ORGID = oldTask.OrgId,
}).ToList();
unitOfWork.GetRepository <LTC_ASSIGNTASK>().InsertRange(newTaskList);
unitOfWork.GetRepository <LTC_ASSIGNTASK>().Delete(oldTask.Id);
unitOfWork.Commit();
return(response);
}
public IActionResult UpdateTask(int id)
{
if (HttpContext.Session.GetString("UserRole") == "1" && HttpContext.Session.GetString("UserRole") != "Expired")
{
var item1 = db.Employee.AsNoTracking().ToList();
ViewBag.Employeeid = new SelectList(item1, "EmployeeId", "EmployeeId");
var item = db.AssignTask.AsNoTracking().Where(a => a.TaskId == id).FirstOrDefault();
AssignTask t = new AssignTask()
{
TaskId = item.TaskId,
TaskTitle = item.TaskTitle,
Description = item.Description,
Date = item.Date,
EmployeeId = item.EmployeeId
};
return(View(t));
}
else
{
return(RedirectToAction("Index", "Home"));
}
}
public IActionResult AddTask(AssignTask a)
{
if (HttpContext.Session.GetString("UserRole") == "1" && HttpContext.Session.GetString("UserRole") != "Expired")
{
AssignTask t = new AssignTask()
{
TaskId = a.TaskId,
TaskTitle = a.TaskTitle,
Description = a.Description,
Date = DateTime.Now,
EmployeeId = a.EmployeeId
};
db.AssignTask.Add(t);
db.SaveChanges();
ViewBag.Success = "Task Assigned Successfully.";
ModelState.Clear();
return(View());
}
else
{
return(RedirectToAction("Index", "Home"));
}
}
public TaskSteps(BrowserDriver driver)
{
this.assignTask = new AssignTask(driver.Current);
}
public IHttpActionResult Post(AssignTask baseRequest)
{
var response = AssignTaskService.SaveAssignTask(baseRequest);
return(Ok(response));
}
public BaseResponse <IList <AssignTask> > QueryAssignTask(BaseRequest <AssignTaskFilter> request)
{
var response = new BaseResponse <IList <AssignTask> >();
var q = from m in unitOfWork.GetRepository <LTC_ASSIGNTASK>().dbSet
join ipd in unitOfWork.GetRepository <LTC_IPDREG>().dbSet on m.FEENO equals ipd.FEENO into ipd_Reg
from ipdReg in ipd_Reg.DefaultIfEmpty()
join regf in unitOfWork.GetRepository <LTC_REGFILE>().dbSet on ipdReg.REGNO equals regf.REGNO into reg_f
from reg_file in reg_f.DefaultIfEmpty()
join emp in unitOfWork.GetRepository <LTC_EMPFILE>().dbSet on m.ASSIGNEE equals emp.EMPNO into emp_f
from emp_file in emp_f.DefaultIfEmpty()
select new
{
AssignTask = m,
ResidentName = reg_file.NAME,
EMPNAME = emp_file.EMPNAME
};
if (request != null && !string.IsNullOrEmpty(request.Data.OrgId))
{
q = q.Where(m => m.AssignTask.ORGID == request.Data.OrgId);
}
if (request != null && request.Data.FeeNo.HasValue)
{
q = q.Where(m => m.AssignTask.FEENO == request.Data.FeeNo);
}
if (request != null && request.Data.RecStatus.HasValue)
{
q = q.Where(m => m.AssignTask.RECSTATUS == request.Data.RecStatus);
}
if (request != null && request.Data.NewRecFlag.HasValue)
{
q = q.Where(m => m.AssignTask.NEWRECFLAG == request.Data.NewRecFlag);
}
if (request != null && request.Data.SDate.HasValue && request.Data.EDate.HasValue)
{
var endDate = request.Data.EDate.Value.AddDays(1);
q = q.Where(m => m.AssignTask.PERFORMDATE >= request.Data.SDate && m.AssignTask.PERFORMDATE < endDate);
}
else if (request != null && request.Data.SDate.HasValue)
{
q = q.Where(m => m.AssignTask.PERFORMDATE >= request.Data.SDate);
}
else if (request != null && request.Data.EDate.HasValue)
{
var endDate = request.Data.EDate.Value.AddDays(1);
q = q.Where(m => m.AssignTask.PERFORMDATE < endDate);
}
if (request != null && !string.IsNullOrWhiteSpace(request.Data.Assignee))
{
q = q.Where(m => m.AssignTask.ASSIGNEE == request.Data.Assignee);
}
q = q.OrderByDescending(m => m.AssignTask.NEWRECFLAG).ThenBy(m => m.AssignTask.RECSTATUS).ThenByDescending(m => m.AssignTask.PERFORMDATE).ThenByDescending(m => m.AssignTask.ID);
response.RecordsCount = q.Count();
Action <IList> mapperResponse = (IList list) =>
{
response.Data = new List <AssignTask>();
foreach (dynamic item in list)
{
AssignTask newItem = Mapper.DynamicMap <AssignTask>(item.AssignTask);
newItem.ResidentName = item.ResidentName;
newItem.EMPNAME = item.EMPNAME;
response.Data.Add(newItem);
}
};
if (request != null && request.PageSize > 0)
{
var list = q.Skip((request.CurrentPage - 1) * request.PageSize).Take(request.PageSize).ToList();
response.PagesCount = GetPagesCount(request.PageSize, response.RecordsCount);
mapperResponse(list);
}
else
{
var list = q.ToList();
mapperResponse(list);
}
//var response = base.Query<LTC_ASSIGNTASK, AssignTask>(request, (q) =>
//{
// if (request != null && !string.IsNullOrEmpty(request.Data.OrgId))
// {
// q = q.Where(m => m.ORGID == request.Data.OrgId);
// }
// if (request != null && request.Data.FeeNo.HasValue)
// {
// q = q.Where(m => m.FEENO == request.Data.FeeNo);
// }
// if (request != null && request.Data.SDate.HasValue && request.Data.EDate.HasValue)
// {
// var endDate = request.Data.EDate.Value.AddDays(1);
// q = q.Where(m => m.ASSIGNDATE >= request.Data.SDate && m.ASSIGNDATE < endDate);
// }
// else if (request != null && request.Data.SDate.HasValue)
// {
// q = q.Where(m => m.ASSIGNDATE >= request.Data.SDate);
// }
// else if (request != null && request.Data.EDate.HasValue)
// {
// var endDate = request.Data.EDate.Value.AddDays(1);
// q = q.Where(m => m.ASSIGNDATE < endDate);
// }
// if (request != null && !string.IsNullOrWhiteSpace(request.Data.Assignee))
// {
// q = q.Where(m => m.ASSIGNEE == request.Data.Assignee);
// }
// q = q.OrderByDescending(m => m.ID);
// return q;
//});
return(response);
}
