public ActionResult Edit(NewTaskViewModel model)
{
try
{
using (var context = new TaskManagerContext())
{
var task = context.Tasks.FirstOrDefault(x => x.TaskId == model.TaskId);
if (task != null && !task.TaskText.Trim().Equals(model.TaskText.Trim(), StringComparison.InvariantCultureIgnoreCase))
{
task.TaskEeventLogs.Add(new TaskEeventLog
{
EventDateTime = DateTime.Now,
PropertyName = "TaskText",
UserId = WebSecurity.CurrentUserId,
OldValue = task.TaskText,
NewValue = model.TaskText
});
task.TaskText = model.TaskText;
context.SaveChanges();
}
}
}
catch (Exception)
{
}
return(RedirectToAction("Index"));
}
private static void ComposeObjects()
{
var api = new ClientApi();
var archiveVm = new ArchiveViewModel();
var commentsVm = new CommentsViewModel();
var newEmployeeVm = new EmployeeViewModel();
var employeesVm = new EmployeesViewModel(newEmployeeVm);
var loginVm = new LoginViewModel(api);
var forgetPasswodVm = new ForgetPasswordViewModel();
var myTasksVm = new MyTasksViewModel();
var newTaskVm = new NewTaskViewModel();
var profileVm = new ProfileViewModel();
var trackingTasksVm = new TrackingTasksViewModel(newTaskVm);
var reportsVm = new ReportsViewModel();
var mainWindowVm = new MainWindowViewModel(archiveVm,
commentsVm,
employeesVm,
loginVm,
forgetPasswodVm,
myTasksVm,
profileVm,
reportsVm,
trackingTasksVm);
Current.MainWindow = new MainWindow(mainWindowVm);
}
/// <summary>
/// Posts the specified new task.
/// </summary>
/// <param name="newTask">The new task.</param>
public void Post(NewTaskViewModel newTask)
{
if (!string.IsNullOrWhiteSpace(newTask.Description) && newTask.StartDate != null)
{
taskManager.CreateTask(newTask, User.Identity.Name);
}
}
public ActionResult Edit(int taskId)
{
var task = ModelHelper.GetTasksById(taskId);
if (task == null)
{
//ModelState.AddModelError("","Указанная заявка не найдена");
return(RedirectToAction("Index"));
}
var model = new NewTaskViewModel
{
TaskId = taskId,
TaskText = task.TaskText,
IsComlete = task.CompleteDate.HasValue,
IsReadOnly = task.TaskRecipient != null,
RecipientName = task.TaskRecipient != null ? task.TaskRecipient.UserFullName : "не назначен",
AssignDate = task.AssignDateTime.HasValue ? task.AssignDateTime.Value.ToString(ModelHelper.DateTimeFormatFull) : string.Empty,
CompleteDate = task.CompleteDate.HasValue ? task.CompleteDate.Value.ToString(ModelHelper.DateTimeFormatFull) : string.Empty,
Deadline = task.Deadline.HasValue ? task.Deadline.Value.ToString(ModelHelper.DateFormat) : string.Empty,
ResultComment = (task.CompleteDate.HasValue && string.IsNullOrEmpty(task.ResultComment)) ? "выполнено" : task.ResultComment,
CreationDate = task.CreateDate.ToString(ModelHelper.DateTimeFormatFull),
CommentsCount = task.Comments.Count
};
return(View(model));
}
public Task CreateNewTask(NewTaskViewModel newTask, string identityName)
{
var project = Context.Boards
.Where(x => x.Id == newTask.ProjectId)
.Include(x => x.Columns)
.ThenInclude(x => x.Tasks)
.Single();
var projectFirstColumn = project.Columns.Single(x => x.Sequence == 1);
var user = Context.Users.SingleOrDefault(x => x.UserName == identityName);
var lastTaskSequence = 0;
if (projectFirstColumn.Tasks.Any())
{
lastTaskSequence = projectFirstColumn.Tasks.Max(x => x.Sequence);
}
var task = new Task()
{
Name = newTask.Name,
Description = newTask.Description,
UserId = user.Id,
ColumnId = projectFirstColumn.Id,
Sequence = lastTaskSequence + 1
};
Context.Tasks.Add(task);
Context.SaveChanges();
return(task);
}
public ActionResult Create(NewTaskViewModel ntvm)
{
ntvm.AdminID = Convert.ToInt32(Session["CurrentUserID"]);
ntvm.DateOfTask = DateTime.Now;
if (ModelState.IsValid)
{
if (Request.Files.Count >= 1)
{
var File = Request.Files[0];
var ImgByte = new Byte[File.ContentLength - 1];
File.InputStream.Read(ImgByte, 0, ImgByte.Length);
var Base64String = Convert.ToBase64String(ImgByte, 0, ImgByte.Length);
ntvm.Attachments = Base64String;
}
this.ts.InsertTask(ntvm);
}
else
{
int SessionID = Convert.ToInt32(Session["CurrentUserID"]);
ModelState.AddModelError("x", "Invalid");
List <Projects> projects = db.projects.Where(temp => temp.AdminID == SessionID).ToList();
List <Users> users = db.users.Where(temp => temp.Role != "Admin").ToList();
ViewBag.Projects = projects;
ViewBag.User = users;
return(View());
}
return(RedirectToAction("Index", "Task", new { area = "Admin" }));
}
public NewTaskWindow()
{
_newTaskViewModel = new NewTaskViewModel {
Owner = this
};
DataContext = _newTaskViewModel;
InitializeComponent();
}
public ActionResult NewTask()
{
ToDoItemsDb db = new ToDoItemsDb(Properties.Settings.Default.ConStr);
NewTaskViewModel vm = new NewTaskViewModel();
vm.Categories = db.GetCategories();
return(View(vm));
}
public void InsertTask(NewTaskViewModel tvm)
{
var Config = new MapperConfiguration(cfg => { cfg.CreateMap <NewTaskViewModel, Tasks>(); });
IMapper mapper = Config.CreateMapper();
Tasks tasks = mapper.Map <NewTaskViewModel, Tasks>(tvm);
tr.InsertTask(tasks);
}
public ActionResult Create(NewTaskViewModel viewModel)
{
var task = Mapper.Map <NewTaskViewModel, Task>(viewModel);
_session.Store(task);
return(Json(Mapper.Map <Task, TaskViewModel>(task)));
}
// Some method that will be called when you want to open another window
public void OpenTheWindow()
{
var modalViewModel = new NewTaskViewModel(Model);
// Create an instance of your new Window and show it.
var win = new NewTaskWindow(modalViewModel);
win.ShowDialog();
}
public NewTaskPage(bool isEditingMode, PlantTask taskToEdit = null)
{
InitializeComponent();
this.DatePicker.MinimumDate = DateTime.Now.Date;
this.TimePicker.Time = TimeSpan.FromHours(8);
this.BindingContext = new NewTaskViewModel(this, isEditingMode, taskToEdit);
vm = this.BindingContext as NewTaskViewModel;
}
public ActionResult Index(NewTaskViewModel newTask)
{
ViewBag.Message = "Please enter task details!";
if (!ModelState.IsValid)
{
return(View(newTask));
}
taskManager.CreateTask(newTask, User.Identity.Name);
return(View(newTask));
}
public IActionResult Add(NewTaskViewModel data)
{
if (!ModelState.IsValid)
{
return(View(data));
}
_taskListService.Add(data.Title, data.Desc);
return(RedirectToAction("Index", "Home"));
}
public IActionResult Add(NewTaskViewModel newTaskViewModel)
{
if (!ModelState.IsValid)
{
return(View(newTaskViewModel));
}
_contetx.Add(newTaskViewModel.Title, newTaskViewModel.Desc);
return(RedirectToAction("Index", "Home"));
}
public IActionResult CreateNewTask([FromBody] NewTaskViewModel newTask)
{
var hasUserAccessToProject = _boardService.HasUserAccessToProject(User.Identity.Name, newTask.ProjectId);
if (!hasUserAccessToProject)
{
return(Unauthorized());
}
var createdTask = _boardService.CreateNewTask(newTask, User.Identity.Name);
return(Ok(createdTask));
}
public NewTaskPage(Guid?taskId = null, Guid?parentId = null)
{
NavigationPage.SetBackButtonTitle(this, "");
//HockeyApp.MetricsManager.TrackEvent("NewTaskPage Initialize");
if (parentId.HasValue)
{
pId = parentId.Value;
}
InitializeComponent();
viewModel = new NewTaskViewModel();
viewModel.StartDate = DateTime.Now.Date;
viewModel.EndDate = DateTime.Now.Date;
StartLoading(selectedTaskId: taskId, selectedProjectId: parentId);
BindingContext = viewModel;
if (Common.UserGlobalCapability != null && Common.UserGlobalCapability.CanCreateProjects)
{
slCreateProject.IsVisible = true;
}
else
{
slCreateProject.IsVisible = false;
}
if (taskId != null && taskId != Guid.Empty)
{
Title = "Edit Task";
slCreateProject.IsVisible = false;
cmbProject.IsEnabled = false;
}
if (Device.RuntimePlatform.ToLower() == "android")
{
//cmbUser.MaximumDropDownHeight = 200;
// cmbProject.Margin = new Thickness(10,0,10,0);
// cmbStartDate.Margin = new Thickness(10, 0, 10, 0);
// cmbEndDate.Margin = new Thickness(10, 0, 10, 0);
// cmbUser.Margin = new Thickness(10, 0, 10, 0);
// txtName.Margin = new Thickness(10, 0, 10, 0);
// txtDescription.Margin = new Thickness(10, 0, 10, 0);
}
else
{
}
}
public MainPage()
{
InitializeComponent();
_viewModel = new NewTaskViewModel();
if (Device.RuntimePlatform == Device.Android)
{
BackgroundColor = Color.BlanchedAlmond;
}
else if (Device.RuntimePlatform == Device.iOS)
{
BackgroundColor = Color.Bisque;
}
}
public IActionResult Create([FromBody] NewTaskViewModel data)
{
//return an error if our model is invalid
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
//add task to the database
_db.Tasks.Add(new Task {
Title = data.Title,
Description = data.Description,
Priority = data.Priority
});
_db.SaveChanges();
return(Ok());
}
public ActionResult NewTask(NewTaskViewModel model)
{
var newTask = new Task
{
CreateDate = DateTime.Now,
SenderId = WebSecurity.CurrentUserId,
TaskText = model.TaskText.Trim()
};
if (!ModelHelper.AddTask(newTask))
{
ModelState.AddModelError("", "Произошла ошибка при добавлении новой заявки. Повторите попытку позже или обратитесь к администратору.");
return(View(model));
}
else
{
return(RedirectToAction("Index"));
}
}
public void StartDialog()
{
NewTaskViewModel ntwm = new NewTaskViewModel();
ntwm.CreateResult += (res) =>
{
if (res == PageDialogResult.Canceled)
{
EndEvent?.Invoke(res);
}
else
{
newTask = ntwm.NewTask;
ResolutionAndDateViewModel rdvm = new ResolutionAndDateViewModel();
rdvm.PerfomerResult += (result) =>
{
if (result == PageDialogResult.Canceled)
{
EndEvent?.Invoke(result);
}
else
{
newTask.Performers = new List <Performer>();
newTask.Performers.Add(new Performer()
{
User = CurrentUser.Instance.User,
Message = rdvm.Message,
PeriodOfExecution = rdvm.Period,
WorkTask = newTask
});
DB.TaskDataBase.Instance.WorkTasks.Add(newTask);
if (DB.TaskDataBase.Instance.SafeSaveChanges())
{
EndEvent?.Invoke(result);
}
}
};
presenter.ShowPage(rdvm);
}
};
presenter.ShowPage(ntwm);
}
public async Task <ActionResult> Create(NewTaskViewModel model)
{
if (ModelState.IsValid)
{
List <ApplicationUser> users = model.UsersId.Select(i => db.Users.Single(u => u.Id == i)).ToList();
Tasks task = new Tasks()
{
Name = model.Name,
Statement = model.Statement,
State = model.State,
DateOfCreate = DateTime.Now,
DateOfUpdate = DateTime.Now,
Users = users,
ProjectId = model.ProjectId
};
db.Tasks.Add(task);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
var usersList = db.Users
.Include(u => u.Profile).ToList()
.Select(u => new { Id = u.Id, Name = $"{u.Profile.FirstName} {u.Profile.LastName}" })
.ToList();
string currentUserId = User.Identity.GetUserId();
int companyId = db.Users.Single(a => a.Id == currentUserId).CompanyId;
var projectsList = db.Project
.Include(p => p.Company)
.Where(p => p.CompanyId == companyId)
.Select(p => new { Id = p.Id, Name = p.Name })
.ToList();
model.ProjectsList = new SelectList(projectsList, "Id", "Name", model.ProjectId);
model.UsersList = new SelectList(usersList, "Id", "Name", model.UsersId);
return(View(model));
}
public List <NewTaskViewModel> GetNewTasksList(int userId)
{
var result = context.Tasks.Include(x => x.ByUser)
.Where(x => x.ToUserId == userId && x.State == 1 && x.Seen == 0);
List <NewTaskViewModel> newTasks = new List <NewTaskViewModel>();
foreach (var data in result)
{
NewTaskViewModel task = new NewTaskViewModel();
task.TaskId = data.Id;
task.ProjectId = data.ProjectId;
task.By = data.ByUser.Name;
task.Priority = data.Priority;
newTasks.Add(task);
}
return(newTasks);
}
public ActionResult AddNewTask(NewTaskViewModel taskView)
{
//TODO: Effort estimation is not saved
//TODO: see how to make the client side validation work.
//TODO: there is a a null pointer exception on DropDownList in case of sending view again due to invalid data
if (!ModelState.IsValid)
{
return(PartialView("NewTask", taskView));
}
//TODO update the behavior so that the responconsible user can be null at creation time and the Initiator shall be the logged user
var userId = HttpContext.User.Identity.GetUserId();
var userModel = _dataManager.FindUserByUserId(userId);
TaskModel model = new TaskModel()
{
Id = 0,
Name = taskView.Name,
TaskInitiatorId = userModel.Id,
ResponsibleUserId = userModel.Id,
Description = taskView.Description,
ProjectId = taskView.ProjectId,
Priority = taskView.Priority,
EffortEstimation = taskView.EffortEstimation,
WorkEffort = 0,
TaskDificultyId = taskView.TaskDificulty,
TaskCreationDate = DateTime.Today,
TaskCompletionDate = null,
Status = TaskState.Open
};
_dataManager.AddTask(model);
_dataManager.SaveChanges();
return(RedirectToAction("ViewProject", "Projects", new { Id = taskView.ProjectId }));
}
public ActionResult NewTask(int projectId)
{
List <TaskDificulty> dificultyLevels = _dataManager.TaskDificultyLevels;
List <TaskDificultyViewModel> taskDificultyViewModelList = new List <TaskDificultyViewModel>();
foreach (var taskDificultyLevel in dificultyLevels)
{
TaskDificultyViewModel taskDificultyViewModel = Mapper.Map <TaskDificultyViewModel>(taskDificultyLevel);
taskDificultyViewModelList.Add(taskDificultyViewModel);
}
NewTaskViewModel viewModel = new NewTaskViewModel()
{
ProjectId = projectId,
PriorityType = TaskPriority.List,
TaskDificultyList = taskDificultyViewModelList,
};
return(PartialView("NewTask", viewModel));
}
/// <summary>
/// Posts the specified new task.
/// </summary>
/// <param name="newTaskViewModel">The new task.</param>
/// <param name="userName">Name of the user.</param>
/// <returns>
/// Created task.
/// </returns>
public Task CreateTask(NewTaskViewModel newTaskViewModel, string userName)
{
var task = new Task
{
UserName = userName,
CreatedDate = DateTime.UtcNow,
Description = newTaskViewModel.Description
};
if (null != newTaskViewModel.StartDate)
{
task.StartDate = newTaskViewModel.StartDate.Value.ToUniversalTime();
}
if (null != newTaskViewModel.EndDate)
{
task.EndDate = newTaskViewModel.EndDate.Value.ToUniversalTime();
}
taskMonitorContext.Tasks.Add(task);
taskMonitorContext.SaveChanges();
return(task);
}
private static string GetName(NewTaskViewModel viewModel)
{
return(viewModel.Name.Substring(0, viewModel.Name.IndexOf("#") - 1));
}
private static IEnumerable <string> GetTags(NewTaskViewModel viewModel)
{
return(from Match match
in Regex.Matches(viewModel.Name, @"\#(\w+)")
select match.Groups[1].Value);
}
public NewTaskPage()
{
InitializeComponent();
_newTaskViewModel = new NewTaskViewModel();
// BindingContext = _newTaskViewModel;
}
