public ActionResult Create(CreateTaskViewModel viewModel)
{
UserTask task = new UserTask()
{
TaskName = viewModel.TaskName,
StatusId = viewModel.Status,
UserId = User.Identity.GetUserId()
};
_context.UserTasks.Add(task);
_context.SaveChanges();
return(RedirectToAction("Index"));
}
private async Task <int> CreateNewTask(CreateTaskViewModel task)
{
if (string.IsNullOrEmpty(task.Inn) ||
task.Inn.Length != Common.Constants.InnLengthIndividual && task.Inn.Length != Common.Constants.InnLengthLegal ||
!(Common.Constants.InnRegex.IsMatch(task.Inn)))
{
throw new PublicException($"ИНН должен coстоять из {Common.Constants.InnLengthIndividual} или {Common.Constants.InnLengthLegal} цифр");
}
if (task.AgentIds == null || task.AgentIds.Length == 0)
{
throw new PublicException("Для задания не назначены агенты");
}
var newTask = new BkTask
{
Date = DateTime.Now,
Inn = task.Inn,
Name = task.Name,
PurposeOfPayment = task.PurposeOfPayment,
IsArchive = false,
TotalCount = task.AgentIds.Length
};
var userManager = HttpContext.GetOwinContext().GetUserManager <BkUserManager>();
var userId = User.Identity.GetUserId();
var clientIdClaim = (await userManager.GetClaimsAsync(userId)).FirstOrDefault(p => p.Type == Common.Constants.ClientIdClaimType);
if (!string.IsNullOrEmpty(clientIdClaim?.Value) && int.TryParse(clientIdClaim.Value, out int clientId))
{
newTask.ClientId = clientId;
}
var taskId = await _taskRepository.CreateTaskAsync(newTask);
foreach (var agentId in task.AgentIds)
{
var resolution = new Data.Models.Resolution
{
AgentId = agentId,
TaskId = taskId,
Decision = null,
Note = string.Empty,
ImageData = string.Empty,
ImageName = string.Empty,
DateTimeDesktopUpdate = DateTime.Now
};
await _resolutionRepository.CreateResolutionAsync(resolution);
}
return(taskId);
}
public async Task <IActionResult> CreateTask([FromBody] CreateTaskViewModel createTask)
{
string token = Request.Headers["Authorization"];
var userID = JWTExtensions.GetDecodeTokenByProperty(token, "nameid").ToInt();
createTask.CreatedBy = userID;
createTask.FromWhoID = userID;
createTask.UserID = userID;
var model = await _taskService.CreateTask(createTask);
// await _hubContext.Clients.All.SendAsync("ReceiveMessage", model.Item2, model.Item3);
// await _hubContext.Clients.All.SendAsync("ReceiveAlertMessage", model.Item2, model.Item3);
return(Ok(model.Item1));
}
public ActionResult Create(CreateTaskViewModel model)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
if (ModelState.IsValid)
{
_apiService.CreateTask(model.ToDto());
}
return(RedirectToAction("GetByProject", new { projectId = model.ProjectId }));
}
public async Task <IActionResult> Create()
{
var user = await this.userManager.GetUserAsync(this.User);
var companyId = this.departmentService.GetCompanyIdByDepartmentId(user.DepartmentId);
var projects = this.projectService.GetAllProjectsByDepartment <ProjectViewModel>(companyId, user.DepartmentId.Value);
var model = new CreateTaskViewModel {
Projects = projects
};
return(this.View(model));
}
public ActionResult AddTask(string id)
{
if (User.IsInRole("Instructor"))
{
Task task = new Task();
CreateTaskViewModel model = new CreateTaskViewModel()
{
TaskListId = id,
Task = task
};
return(View(model));
}
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
/// <summary>
/// Creates CreateTaskViewModel object with given Description,
/// Priority level and Task list id.
/// </summary>
/// <param name="description">Task description.</param>
/// <param name="priorityLevel">Task priority level.</param>
/// <param name="taskListId">Task list id</param>
/// <returns>Created CreateTaskViewModel object.</returns>
protected static CreateTaskViewModel BuildCreateTaskViewModel(
string description = "Default",
int priorityLevel = (int)TaskPriorityLevel.Low,
int taskListId = 3)
{
var createTaskViewModel = new CreateTaskViewModel()
{
Description = description,
PriorityLevel = (TaskPriorityLevel)priorityLevel,
TaskListId = taskListId
};
return(createTaskViewModel);
}
public ActionResult CreateTask(int projectId)
{
var projectMembers = _projectMemberRepository.GetAllBy(p => p.ProjectId == projectId, "Employee.User.Person").ToList().Select(m => m.MemberEmployee).ToList();
ViewBag.AssigneeId = new SelectList(projectMembers, "Id", "Person.Name", WebUser.Id);
var vm = new CreateTaskViewModel
{
TaskStatus = ProjectTaskStatus.Notstarted,
Priority = TaskPriority.Normal,
StartDate = DateTime.Now
};
return(View(vm));
}
public ActionResult CreateTask(CreateTaskViewModel vm)
{
if (ModelState.IsValid)
{
var newTask = new Task
{
Title = vm.Title,
Description = vm.Description,
ExpectedTime = vm.ExpectedTime,
ActualTime = vm.ActualTime,
TaskStatus = vm.TaskStatus,
Priority = vm.Priority,
AssigneeId = vm.AssigneeId,
StartDate = vm.StartDate,
DueDate = vm.DueDate,
ProjectId = vm.ProjectId,
ParentId = vm.ParentId,
CreatedByUserId = WebUser.Id
};
_taskRepository.Create(newTask);
_unitOfWork.Commit();
// Update Task Code
var selectedTask = _taskRepository.Get(newTask.Id);
if (selectedTask != null)
{
selectedTask.Code = $"TK{newTask.Id}";
_taskRepository.Update(selectedTask);
_unitOfWork.Commit();
var assignedToUser = _userRepository.Get(selectedTask.AssigneeId.GetValueOrDefault());
if (assignedToUser != null)
{
_notificationService.NotifyUser("New Task", selectedTask.Title, assignedToUser.Code);
}
}
return(RedirectToAction("Details", "Projects", new { Id = newTask.ProjectId }));
}
var projectMembers = _projectMemberRepository.GetAllBy(p => p.ProjectId == vm.ProjectId, "MemberEmployee.User.Person").ToList().Select(m => m.MemberEmployee).ToList();
ViewBag.AssigneeId = new SelectList(projectMembers, "Id", "Person.Name");
return(View(vm));
}
public void AddTask(CreateTaskViewModel task)
{
var student = _studentTeacherRepository.GetStudents().Where(x => x.TeacherEmail == task.teacherEmail).ToArray();
foreach (var students in student)
{
Task tasks = new Task()
{
taskTitle = task.taskTitle,
taskDescription = task.taskDescription,
taskDeadline = task.taskDeadline,
StudentEmail = students.StudentEmail,
TeacherEmail = task.teacherEmail
};
_createTaskRepo.AddTask(tasks);
}
}
private Data.Enum.JobType CheckJobType(CreateTaskViewModel task)
{
switch (task.JobTypeID)
{
case Data.Enum.JobType.Project:
return(Data.Enum.JobType.Project);
case Data.Enum.JobType.Routine:
return(Data.Enum.JobType.Routine);
case Data.Enum.JobType.Abnormal:
return(Data.Enum.JobType.Abnormal);
default:
return(Data.Enum.JobType.Unknown);
}
}
public ActionResult Create(int?projectId)
{
var myProjects = GetAllProjectsForMe();
var userList = GetAllMyReportees();
ViewBag.AssigneeId = new SelectList(userList, "Id", "Person.Name", WebUser.Id);
ViewBag.ProjectId = new SelectList(myProjects, "Id", "Title", projectId);
var vm = new CreateTaskViewModel
{
TaskStatus = ProjectTaskStatus.Notstarted,
Priority = TaskPriority.Normal,
StartDate = DateTime.Now
};
return(View(vm));
}
public ActionResult Edit(CreateTaskViewModel viewModel)
{
var userId = User.Identity.GetUserId();
var task = _context.UserTasks.SingleOrDefault(t => t.Id == viewModel.Id && t.UserId == userId);
if (task == null)
{
return(RedirectToAction("Index"));
}
task.TaskName = viewModel.TaskName;
task.StatusId = viewModel.Status;
_context.SaveChanges();
return(RedirectToAction("Index"));
}
public async Task ReturnsPayloadWithTaskId_WhenTaskIsCreated()
{
var createTaskPayload = new CreateTaskViewModel {
Title = "Test task"
}.ToJsonContent();
var mockTaskCreator = Substitute.For <ITaskCreator>();
var newTaskId = Guid.NewGuid().ToString();
mockTaskCreator.CreateTask(Arg.Any <ITask>()).Returns(newTaskId);
var http = CreateHttpClient(Substitute.For <ITaskRepository>(), mockTaskCreator);
var response = await http.PostAsync(Constants.BaseTaskUrl, createTaskPayload);
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
Assert.Contains($"{Constants.BaseTaskUrl}/{newTaskId}", response.Headers.Location.ToString());
Assert.Contains($@"""taskId"":""{newTaskId}""", await response.Content.ReadAsStringAsync());
}
public async Task CreateAsync(CreateTaskViewModel model)
{
var task = new ProjectTasks
{
Tittle = model.Tittle,
Description = model.Description,
EstimatedWorkHours = model.EstWorkHours,
Status = model.Status,
CreatedOn = DateTime.UtcNow,
IsDeleted = false,
ProjectId = model.ProjectId
};
await this.tasksRepository.AddAsync(task);
await this.tasksRepository.SaveChangesAsync();
}
public IActionResult Create(CreateTaskViewModel model)
{
if (!AdminAuthorization())
{
return(RedirectToAction("/"));
}
var affectedSectors = new List <string>
{
model.Customers,
model.Marketing,
model.Finances,
model.Internal,
model.Management
};
service.CreateTask(model.Title, model.DueDate, model.Description, model.Participants, affectedSectors);
return(RedirectToAction("/"));
}
public ActionResult AddConversion(CreateTaskViewModel model)
{
//if (!ModelState.IsValid)
// return View(model);
bool isEdited = new TASK_Service().AddTaskByViewModel(model);
FlashMessage.Confirmation(@UiStrings.add_conversion_message_added_to_cart);
if (model.ShortEditUserViewModel.PK_ID_USER == 0)
{
return(LoginAuto(model.ShortEditUserViewModel));
}
else
{
return(RedirectToAction("Index"));
}
}
public IActionResult CreateTask(int id, CreateTaskViewModel model)
{
if (ModelState.IsValid)
{
var userid = this.User.FindFirstValue(ClaimTypes.NameIdentifier);
var workspace = _context.Workspaces.SingleOrDefault(x => x.WorkspaceId == id && x.PmId == userid);
if (workspace != null)
{
TimeSheetManagement.Models.Task task = new TimeSheetManagement.Models.Task();
task.TaskName = model.TaskName;
task.WorkspaceId = workspace.WorkspaceId;
_context.Tasks.Add(task);
_context.SaveChanges();
return(RedirectToAction("WorkspaceTasks", new { Id = id }));
}
}
return(View(model));
}
public IHttpResponse Create(CreateTaskViewModel model)
{
var task = model.To <Task>();
if (DateTime.TryParse(model.DueDate, out DateTime dueDate))
{
task.DueDate = dueDate;
}
var properties = model.GetType().GetProperties();
var taskSectors = new List <TaskSector>();
foreach (var prop in properties)
{
var value = prop.GetValue(model);
if (value != null)
{
bool isValidSector = Enum.TryParse(typeof(Models.Enums.Sector), value.ToString(),
out object sectorValue);
if (isValidSector)
{
var sector = new Models.Sector
{
Name = (Models.Enums.Sector)sectorValue
};
var taskSector = new TaskSector
{
Task = task,
Sector = sector
};
taskSectors.Add(taskSector);
}
}
}
task.AffectedSectors.AddRange(taskSectors);
Db.Tasks.Add(task);
Db.SaveChanges();
return(this.Redirect("/"));
}
public ActionResult Edit(int id)
{
//Make sure task in route exists
var task = _context.UserTasks.Where(t => t.Id == id).FirstOrDefault();
if (task == null)
{
return(RedirectToAction("Index"));
}
var viewModel = new CreateTaskViewModel {
Id = task.Id,
Statuses = GetStatuses(),
TaskName = task.TaskName,
Status = task.StatusId
};
return(View(viewModel));
}
public ActionResult CreateTaskResult(CreateTaskViewModel model)
{
if (model.Name == null || model.Name == "" || model.Content == null || model.Content == "")
{
RedirectToAction("Index", "Home");
}
//model.Author = User.Identity.Name;
var taskmodel = new Task();
//{
taskmodel.NameOfTask = model.Name;
taskmodel.ContentOfTask = model.Content;
var category = categoryRepositoryitory.FindByID(model.SelectCategoryId);//.GetEnumerator().Current;
//var CategoryN = categoryRepositoryitory.Get(category => category.ID == model.SelectCategoryId).ToString();
//taskmodel.Category = category;
taskmodel.CategoryId = category.ID;
taskmodel.CategoryName = category.CategoryName;
taskmodel.UserCreated = User.Identity.Name;
taskmodel.Likes = 0;
taskmodel.Dislikes = 0;
taskmodel.RatingOfTask = 0;
taskmodel.Locked = false;
taskmodel.UserCreated = User.Identity.Name;
if (model.Answers != null)
{
ICollection <Answers> answers = new Collection <Answers>();
List <String> modelAnswers = System.Web.Helpers.Json.Decode <List <String> >(model.Answers);
foreach (String ans in modelAnswers)
{
Answers answer = new Answers();
answer.ContentOfAnswer = ans;
answer.TaskID = taskmodel.ID;
answers.Add(answer);
answersRepository.Insert(answer);
}
taskmodel.Answers = answers;
}
taskRepository.Insert(taskmodel);
return(RedirectToAction("Index", "Home"));
}
public JsonResult CreateTask(CreateTaskViewModel task)
{
var userId = User.GetLoggedInUserId <string>();
var subjectUsers = _subjectService.GetSubjectUsers(task.SubjectId);
foreach (var subjectUser in subjectUsers)
{
var subjectTask = new Task
{
Name = task.Name,
Description = task.Description,
DeadLine = task.DeadLine,
StatusId = (int)Common.Enums.TaskStatus.Proposed,
MaxAssessment = task.MaxAssessment,
CreatedById = userId,
SubjectId = task.SubjectId,
DateCreated = DateTime.UtcNow
};
_taskService.CreateTask(subjectTask);
var userTaskMapping = new UserTaskMapping
{
UserId = subjectUser.User.Id,
TaskId = subjectTask.Id
};
_taskService.CreateUserTaskMapping(userTaskMapping);
var teacherTaskMapping = new TeacherTaskMapping
{
TeacherId = userId,
TaskId = subjectTask.Id
};
_taskService.CreateTeacherTaskMapping(teacherTaskMapping);
}
return(CreateJsonResult(true));
}
public ActionResult Create(Guid goalId, CreateTaskViewModel model)
{
if (ModelState.IsValid)
{
Task entity = MapCreateTaskViewModelToEntity(model);
try
{
_service.Create(goalId, entity);
}
catch
{
ModelState.AddModelError("", "Error saving task");
return(View(model));
}
return(RedirectToAction("Index", new { goalId }));
}
return(View(model));
}
public async Task <IActionResult> PostTaskModel([FromBody] CreateTaskViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = await _userManager.GetUserAsync(User);
TaskModel taskModel = new TaskModel
{
Description = model.Description,
DueDate = model.DueDate,
IsCompleted = false,
TaskName = model.TaskName,
UserId = user.Id
};
_taskRepository.CreateAsync(taskModel);
return(Created("task/taskAPI", "Created successfully"));
// return CreatedAtAction("GetTaskModel", new { id = taskModel.TaskId }, taskModel);
}
public async Task <ActionResult> Create(CreateTaskViewModel createTaskViewModel)
{
Models.Task task = new Models.Task
{
Name = createTaskViewModel.TaskName,
Description = createTaskViewModel.TaskDescription
};
if (ModelState.IsValid)
{
await _repo.CreateAsync(task, createTaskViewModel.SelectedValue);
return(RedirectToAction("Index"));
}
else
{
createTaskViewModel.Employees = await _repoEmp.GetAllEmployeesAsync();
return(View(createTaskViewModel));
}
}
public ActionResult Update(int?projectId, int?taskId, CreateTaskViewModel model)
{
if (!projectId.HasValue || !taskId.HasValue)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
if (ModelState.IsValid)
{
var task = _taskRepository.GetById(taskId.Value);
if (task == null)
{
return(HttpNotFound());
}
task.Title = model.Title;
task.Description = model.Description;
task.AssigneeId = model.AssigneeId;
_taskRepository.Update(task);
return(RedirectToAction("ViewTask", new { projectId, taskId }));
}
return(View("EditTask", model));
}
public IActionResult Create(CreateTaskViewModel model)
{
var title = model.Title.UrlDecode();
var dueDate = DateTime.ParseExact(model.DueDate, "yyyy-MM-dd", CultureInfo.InvariantCulture);
var description = model.Description.UrlDecode();
var participants = model.Participants.UrlDecode();
var task = this.taskService.AddTask(title, dueDate, description, participants);
this.taskService.AddTaskSectors(model.SectorCustomers, model.SectorMarketing, model.SectorFinances, model.SectorInternal, model.SectorManagement, task.Id);
var username = this.Identity.Username;
var user = this.userService.GetUser(username);
var date = DateTime.UtcNow.Date;
var status = this.GenerateStatus();
this.reporterService.AddReport(date, status, task.Id, user.Id);
return(new RedirectResult("/"));
}
public IActionResult Create(CreateTaskViewModel viewModel)
{
var task = new TaskModel
{
Created = DateTime.Now,
CreatedBy = User.Identity.Name,
Status = Strings.TaskStatus.Open,
Description = viewModel.Description,
Owner = viewModel.SelectedOwner,
History = new List <TaskHistoryModel>()
};
_database.Tasks.Add(task);
var historyEntry = task.AddHistory($"Created by {User.Identity.Name}");
_database.TaskHistory.Add(historyEntry);
_database.SaveChanges();
return(RedirectToAction("Index"));
}
public Tasks Create(CreateTaskViewModel model, AppUsers ofUser, string createdUserId)
{
var entity = Convert(model);
entity = PrepareCreate(entity);
entity.CreatedUser = createdUserId;
entity.OfUser = ofUser.Id;
var status = new List <string> {
"NEW"
};
if (ofUser.Id != createdUserId)
{
status.Add("ACCEPTED");
}
entity.Status = JsonConvert.SerializeObject(status);
entity = Create(entity).Entity;
return(entity);
}
public ActionResult AddTask(CreateTaskViewModel taskViewModel)
{
if (taskViewModel == null || taskViewModel.SkillId == 0)
{
return(null);
}
Task task = new Task()
{
Number = taskViewModel.Number,
Name = taskViewModel.Name,
Description = taskViewModel.Description,
Note = taskViewModel.Note,
Materials = Mapper.Map <ICollection <Material> >(taskViewModel.Materials),
SkillId = taskViewModel.SkillId
};
_context.Tasks.Add(task);
_context.SaveChanges();
return(View());
}
