public async Task <IActionResult> Create([FromBody] CreateTaskModel model)
{
try
{
if (TaskTypes.IsReserved(model.TypeId))
{
return(Error(HttpStatusCode.BadRequest, "Tasks of this type cannot be created manually."));
}
var user = await GetLoggedInUser();
var accessResponse = await GetPermissionsForTasksPerson(model.AssignedToId, true);
if (accessResponse.CanAccess || accessResponse.IsOwner)
{
model.AssignedById = user.Id.Value;
await _taskService.Create(model);
return(Ok());
}
return(Error(HttpStatusCode.Forbidden, "You do not have permission to create tasks for this person."));
}
catch (Exception e)
{
return(HandleException(e));
}
}
public async Task <IActionResult> Create([FromForm] CreateTaskModel model)
{
return(await ProcessAsync(async() =>
{
if (TaskTypes.IsReserved(model.TypeId))
{
return BadRequest("This task type cannot be created manually.");
}
var user = await UserService.GetUserByPrincipal(User);
var canCreate = await AuthoriseCreate(model.AssignedToId, user.Id);
if (canCreate)
{
var task = new TaskModel
{
AssignedToId = model.AssignedToId,
AssignedById = user.Id,
Title = model.Title,
Description = model.Description,
DueDate = model.DueDate,
CreatedDate = DateTime.Now,
TypeId = model.TypeId,
Completed = false
};
await _taskService.Create(task);
return Ok("Task created successfully.");
}
return Forbid();
}));
}
public UserTodoList CreateTodo(CreateTaskModel createTaskModel, string userId, string userName)
{
var userTodoList = GetUserTodoListByUserId(userId);
if (userTodoList == null)
{
userTodoList = new UserTodoList
{
Id = Guid.NewGuid(),
TodoList = new List <Todo>(),
UserId = userId,
UserName = userName
};
UserTodoLists.Add(userTodoList);
}
var todo = new Todo
{
Id = Guid.NewGuid(),
DueDate = createTaskModel.DueDate.GetValueOrDefault(DateTime.UtcNow),
Description = createTaskModel.Description,
Status = createTaskModel.Status
};
userTodoList.TodoList.Add(todo);
return(userTodoList);
}
public TaskEntityModel Task(CreateTaskModel model)
{
using (var repo = new TaskRepository(_taskDataContext))
{
var task = model.Map();
// commit new task to db
return(repo.Create(task));
}
}
public IHttpActionResult CreateTask(Guid projectId, CreateTaskModel model)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
var task = _repository.CreateTask(projectId, model.Name, model.Description, model.AvailableTime);
return CreatedAtRoute("GetTaskRoute", new { projectId, task.Id }, task);
}
public void Create(CreateTaskModel model)
{
var affectedSectors = new List <TaskSector>();
var task = new Task
{
Title = model.Title,
DueDate = DateTime.ParseExact(model.DueDate, "yyyy-MM-dd", CultureInfo.InvariantCulture),
Description = model.Description,
IsReported = false
};
foreach (Sector value in Enum.GetValues(typeof(Sector)))
{
var property = model
.GetType()
.GetProperties()
.FirstOrDefault(p => p.Name.ToLower()
.Equals(value.ToString().ToLower()));
if (property.GetValue(model) != null)
{
var taskSector = new TaskSector
{
Task = task,
Sector = value
};
affectedSectors.Add(taskSector);
}
}
var participants = new List <TaskParticipant>();
foreach (var name in model.Participants.Split(new[] { ", ", "," }, StringSplitOptions.RemoveEmptyEntries))
{
var participant = new TaskParticipant
{
Name = name.Trim(),
Task = task
};
participants.Add(participant);
}
task.Participants = participants;
task.AffectedSectors = affectedSectors;
task.Level = affectedSectors.Count();
this.context.Tasks.Add(task);
this.context.SaveChanges();
//this.context.TaskParticipants.AddRange(participants);
//this.context.SaveChanges();
//this.context.TaskSectors.AddRange(affectedSectors);
}
public ActionResult Create([FromBody] CreateTaskModel model)
{
var response = _workUnit.CreateTask(model.Name, model.Description, model.ProjectId);
if (!response.Success)
{
return(BadRequest(response));
}
return(Ok(response));
}
public async Task <SprintTask> AddTask(Guid guid, [FromBody] CreateTaskModel model)
{
var task = new SprintTask {
SwimlaneGuid = guid, Title = model.Title, Description = model.Description
};
_db.Tasks.Add(task);
await _db.SaveChangesAsync();
return(task);
}
public IHttpActionResult CreateTask(Guid projectId, CreateTaskModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var task = _repository.CreateTask(projectId, model.Name, model.Description, model.AvailableTime);
return(CreatedAtRoute("GetTaskRoute", new { projectId, task.Id }, task));
}
public async Task <IActionResult> CreateTaskAsync([FromBody] CreateTaskModel createTaskModel)
{
var user = (User)HttpContext.Items["currentUser"];
if (user == null)
{
return(NotFound($"User not found"));
}
var task = await _taskService.CreateTaskAsync(createTaskModel.Description, user);
return(Created(@$ "api/tasks/{task.Id}", task));
}
public async Task <IActionResult> CreateTask([FromBody] CreateTaskModel taskModel)
{
TaskDto task = new TaskDto();
task.Name = taskModel.NameTask;
task.Description = taskModel?.Description;
await _userService.AddTask(UserId, task);
await _taskService.CreateTask(task);
return(Ok(true));
}
public IActionResult CreateTask([FromBody] CreateTaskModel model)
{
var taskDefinition = Invariant(
$@"<Task type=""AAT"" task_scored=""0"" aat_min_time=""10800"" start_max_speed=""60"" start_max_height=""0"" start_max_height_ref=""MSL"" finish_min_height=""0"" finish_min_height_ref=""AGL"" fai_finish=""0"" min_points=""2"" max_points=""13"" homogeneous_tps=""0"" is_closed=""0"">
<Point type=""Start"">
<Waypoint name=""Start"" id=""0"" comment="""" altitude=""-999.0"">
<Location longitude=""{model.Lng}"" latitude=""{model.Lat}""/>
</Waypoint>
<ObservationZone type=""Line"" length=""10000.0""/>
</Point>
<Point type=""Area"">
<Waypoint name=""WP1"" id=""0"" comment="""" altitude=""-999.0"">
<Location longitude=""{model.Lng}"" latitude=""{model.Lat + 0.5}""/>
</Waypoint>
<ObservationZone type=""Cylinder"" radius=""10000.0""/>
</Point>
<Point type=""Area"">
<Waypoint name=""WP2"" id=""0"" comment="""" altitude=""128.0"">
<Location longitude=""{model.Lng + 0.5}"" latitude=""{model.Lat + 0.25}""/>
</Waypoint>
<ObservationZone type=""Cylinder"" radius=""10000.0""/>
</Point>
<Point type=""Finish"">
<Waypoint name=""Finish"" id=""0"" comment="""" altitude=""-999.0"">
<Location longitude=""{model.Lng}"" latitude=""{model.Lat}""/>
</Waypoint>
<ObservationZone type=""Line"" length=""10000.0""/>
</Point>
</Task>" );
var day = _dbContext.Days.FirstOrDefault(x => x.Id == model.DayId);
day.Task = taskDefinition;
day.TaskFileFormat = "XcSoar";
var task = XcSoarTask.Parse(taskDefinition);
if (task != null)
{
_dbContext.SaveChanges();
var serializerSettings = new JsonSerializerSettings
{
ContractResolver = new Newtonsoft.Json.Serialization.DefaultContractResolver(),
ReferenceLoopHandling = ReferenceLoopHandling.Ignore
};
return(new JsonResult(task, serializerSettings));
}
return(Ok());
}
public async Task <ActionResult> CreateTask(CreateTaskModel data)
{
TodoTask todoTask = new TodoTask {
ListID = data.ListID,
TaskName = data.TaskName,
Description = data.Description,
Colour = "black",
};
await _todoTaskRepository.SaveAsync(todoTask);
return(RedirectToAction("Index", "Home"));
}
private async void OnCreated(CreateTaskModel @event)
{
var doc = new TaskContent
{
Id = @event.Id.ToString(),
AssignedTo = @event.AssignedBy,
CreatedBy = @event.CreatedBy,
Status = @event.Status,
Title = @event.Title
};
await _taskContentRepository.AddAsync(doc);
}
public async Task <IActionResult> Create([FromForm] CreateTaskModel taskDetail)
{
try
{
int taskId = await _createTask.CreateNewTask(taskDetail);
return(Created(new Uri($"{Request.Path}/{taskId}", UriKind.Relative), taskDetail));
}
catch (Exception e)
{
return(StatusCode(500));
}
}
private void btnSelectFile_Click(object sender, RoutedEventArgs e)
{
string choosenFilePath;
choosenFilePath = CreateTaskModel.SelectFileReturnPath();
if (choosenFilePath != "")
{
FilePath.Text = choosenFilePath;
}
else
{
MessageBox.Show("Ошибка выбора файла");
}
}
public async Task <NewTaskResult> Create(CreateTaskModel createTaskModel)
{
await loadAuthTask;
var content = JsonSerializer.Serialize(createTaskModel);
var response = await _httpClient.PostAsync($"api/TaskModel", new StringContent(content, Encoding.UTF8, "application/json"));
var text = await response.Content.ReadAsStringAsync();
var output = JsonSerializer.Deserialize <NewTaskResult>(text, new JsonSerializerOptions {
PropertyNameCaseInsensitive = true
});
return(output);
}
public async Task <int> CreateNewTask(CreateTaskModel taskDetail)
{
var task = new Domain.Task {
TaskName = taskDetail.TaskName,
Description = taskDetail.Description,
ListId = null,
StatusId = 1,
CreatedDate = DateTime.Now
};
_ternContext.Tasks.Add(task);
await _ternContext.SaveChangesAsync();
return(task.TaskId);
}
public static TaskEntity ToTaskEntity(this CreateTaskModel taskModel, int userId, List <int> tagsId, List <int> photoId)
{
return(new TaskEntity()
{
Id = taskModel.Id,
Complexity = taskModel.Complexity,
Category = taskModel.Category,
CreateUserId = userId,
Name = taskModel.Name,
Condition = taskModel.Condition,
TagsId = tagsId,
Answers = taskModel.Answers,
PhotoId = photoId
});
}
public async Task <IActionResult> Create([FromBody] CreateTaskModel createTaskModel)
{
var user = await _userManager.FindByNameAsync(User.Identity.Name);
var id = await _taskRepository.NewTask(createTaskModel, user.ID.ToString());
if (id == 0)
{
return(BadRequest(new NewTaskResult {
Successful = false
}));
}
return(Ok(new NewTaskResult {
ID = id, Successful = true
}));
}
public IHttpResponse Create(CreateTaskModel model)
{
if (this.User.Username == null)
{
return(this.Redirect("/"));
}
if (!this.User.IsAdmin)
{
return(this.Redirect("/"));
}
this.taskService.Create(model);
return(this.Redirect("/"));
}
public async Task <ActionResult <CreateTaskModel> > PostTask(CreateTaskModel model)
{
var task = _mapper.Map <ProjectTask>(model);
var project = await _context.Projects.Include(p => p.Tasks).SingleOrDefaultAsync(p => p.Id == model.ProjectId);
if (project == null)
{
return(BadRequest(new { message = $"Project with id {model.ProjectId} was not found" }));
}
project.Tasks.Add(task);
await _context.SaveChangesAsync();
//return CreatedAtAction("GetProject", new { controller = "Projects", id = model.ProjectId}, project); //TODO: Cyclic dependency issue
return(Ok());
}
private void SaveButton_Click(object sender, RoutedEventArgs e)
{
if (DateTimePicker.Text == "")
{
MessageBox.Show("Выберите дату и время");
return;
}
string dateTimeString = DateTimePicker.Text;
DateTime dateTime = Convert.ToDateTime(dateTimeString);
if (!CreateTaskModel.CheckUniqueDateTime(dateTime))
{
MessageBox.Show("Время уже занято");
return;
}
CreateTaskModel.SaveTask(nameField.Text, descriptionField.Text, dateTime, FilePath.Text);
}
public async Task <IActionResult> Create(CreateTaskModel model, CancellationToken token)
{
if (ModelState.IsValid)
{
await this.todoTaskService.CreateAsync(new TodoTask
{
Name = model.Name,
Urgency = model.Urgency,
Importance = model.Importance,
IsFinished = false
}, token);
return(RedirectToAction(nameof(Index)));
}
return(View(model));
}
public void GetTaskIncentives_equal_incentivekinds()
{
using (var tx = TxManager.Acquire())
{
using (var session = this.Services.ResolveSessionProvider().GetSession())
{
var incentiveKindManager = this.Services.GetRequiredService<IIncentiveKindManager>();
var taskManager = this.Services.GetRequiredService<ITaskManager>();
var taskIncentiveManager = this.Services.GetRequiredService<ITaskIncentiveManager>();
var accountManager = this.Services.GetRequiredService<IAccountManager>();
var orgManager = this.Services.GetRequiredService<IOrgManager>();
var staffManager = this.Services.GetRequiredService<IStaffManager>();
//创建一个账号
var accountName = "Test-Account-Incentive-0001";
var account = accountManager.CreateAccount(accountName, "123456", $"{accountName}@example.com",
"13701472527");
session.SaveChanges();
//创建一个组织
var org = orgManager.CreateOrg(account, "Test-Org-Incentive-0001", null);
session.SaveChanges();
//添加一个员工
var staff = staffManager.CreateStaff(org.Id, account.Id, account.Name);
session.SaveChanges();
//创建一个任务
var taskModel = new CreateTaskModel();
taskModel.Name = "Test-Task-Incentives-0001";
taskModel.CreatorStaffId = staff.Id;
var task = taskManager.CreateTask(taskModel);
session.SaveChanges();
var kinds = incentiveKindManager.FetchIncentiveKind();
var taskIncentives =
taskIncentiveManager.FetchTaskIncentiveByTaskId(task.Id);
Assert.AreEqual(kinds.Count(), taskIncentives.Count());
}
tx.NoComplete();
}
}
public ActionResult CreateTask(CreateTaskModel model, HttpPostedFileBase file)
{
if (ModelState.IsValid)
{
var auth = authorizationService.Get(User.Identity.Name);
int id = auth.UserId;
List <int> photosId = new List <int>();
if (file != null)
{
byte[] fileContext = new byte[file.ContentLength];
file.InputStream.Read(fileContext, 0, file.ContentLength);
photosId.Add(photoService.CreatePhoto(fileContext));
}
taskService.CreateTask(model.ToTaskEntity(id, tagService.CreateTags(model.Tag).ToList(), photosId));
return(RedirectToAction("Index", "Home"));
}
return(View(model));
}
public async Task <int> NewTask(CreateTaskModel createTaskModel, string creatorID)
{
int output;
using (var cnn = DbConnection)
{
var procedure = "[CreateTask]";
var values = new
{
Creator = creatorID,
createTaskModel.Deadline,
createTaskModel.Priority,
createTaskModel.Name,
createTaskModel.Description,
createTaskModel.Note
};
output = await cnn.QueryFirstOrDefaultAsync <int>(procedure, values, commandType : CommandType.StoredProcedure);
}
return(output);
}
public IActionResult CreateTask(CreateTaskModel createProjectModel)
{
ProjectTask projectTask = createProjectModel.ProjectTask;
projectTask.Employee = new Employee()
{
Id = createProjectModel.EmployeeId
};
projectTask.Project = new Project()
{
Id = createProjectModel.ProjectId
};
OperationStatusInfo operationStatusInfo = _hubEnvironment.ServerHubConnector.CreateProjectTask(projectTask).Result;
if (operationStatusInfo.OperationStatus == OperationStatus.Done)
{
return(RedirectToAction("TaskList"));
}
else
{
return(RedirectToAction("CreateTaskPage"));
}
}
//public override bool OnCreateOptionsMenu(IMenu menu)
//{
// MenuInflater.Inflate(Resource.Menu.menu_main, menu);
// return true;
//}
public async Task ManualSyncData()
{
if (ic.connectivity())
{
try
{
progress = new ProgressDialog(this);
progress.Indeterminate = true;
progress.SetProgressStyle(Android.App.ProgressDialogStyle.Spinner);
progress.SetCancelable(false);
progress.SetMessage("Please wait...");
progress.Show();
List <CreateTaskModel> dataList = db.getCreateTaskData("no");
if (dataList != null && dataList.Count > 0)
{
long id;
foreach (var val in dataList)
{
id = val.Id;
CreateTaskModel model = new CreateTaskModel();
model.taskname = val.taskname;
model.taskdescrip = val.taskdescrip;
model.deadline = val.deadline;
model.through = val.through;
model.markto = val.markto;
model.lstTaskFileMapping = val.lstTaskFileMapping;
string json = JsonConvert.SerializeObject(model);
try
{
string item = await restService.CreateTaskMethod(this, json, location);
if (item.Contains("Success"))
{
//db.InsertCreateTaskData(taskname, taskdescri, deadline, "mobile", markto, "yes");
//Toast.MakeText(Activity, "Task Assign Successfully..", ToastLength.Long).Show();
Toast.MakeText(this, "Oops! something went wrong. Please try again later.", ToastLength.Long).Show();
progress.Dismiss();
}
else
{
//db.InsertCreateTaskData(taskname, taskdescri, deadline, "mobile", markto, "yes");
Toast.MakeText(this, "Data Synced", ToastLength.Long).Show();
db.updatetaskstatus(id);
//Toast.MakeText(Activity, "Oops! something went wrong. Please try again later.", ToastLength.Long).Show();
progress.Dismiss();
}
}
catch (Exception ex)
{
progress.Dismiss();
}
}
}
}
catch (Exception ex)
{
progress.Dismiss();
}
progress.Dismiss();
}
progress.Dismiss();
}
public async Task <IActionResult> CreateTask([FromBody] CreateTaskModel taskchannel)
{
var response = await Mediator.Send(new CreateTaskRequest { Task = taskchannel });
return(Accepted(response));
}
public async Task <(bool IsDone, string Message)> CreateTaskAsync(Guid userId, CreateTaskModel model)
{
try
{
var access = await _securityService.GetUserAccessAsync(userId, model.ProjectId);
if (!access[UserAction.CREATE_TASK])
{
return(IsDone : false, Message : "Access denied");
}
var column = await _context.Columns.FindAsync(model.ColumnId);
var board = await _context.Boards.FindAsync(column.BoardId);
var assigneeId = _context.Users.SingleOrDefault(x => x.Email == model.AssigneeEmail)?.Id;
var attachments = model.Attachments == null ? null : await ToAttachments(model.Attachments);
var task = new DataProvider.Entities.Task
{
Title = $"{board.TaskPrefix}-{board.TaskIndex} {model.Title}",
ColumnId = model.ColumnId,
CreatorId = userId,
AssigneeId = assigneeId,
Content = model.Content ?? "",
Priority = model.Priority,
Severity = model.Severity,
Type = model.Type,
Attachments = attachments
};
await _context.Tasks.AddAsync(task);
board.TaskIndex++;
_context.Update(board);
await _context.SaveChangesAsync();
if (assigneeId != null)
{
var notification = new CreateNotificationModel
{
Subject = "You were assigned to task",
Description = $"You were assigned to {task.Title}",
DirectLink = $"/project/{model.ProjectId}/board/{column.BoardId}",
RecipientEmail = model.AssigneeEmail
};
await _notificationService.CreateNotificationAsync(notification);
}
return(IsDone : true, Message : "Success");
}
catch (Exception e)
{
_logger.LogError("TaskService: CreateTaskAsync", e);
}
return(IsDone : false, Message : "Something went wrong, try again later");
}
private void ForPartakerReq(PartakerReqAction callback)
{
var sf = this.Services.GetRequiredService<ISessionProvider<AefSession>>();
var accountManager = this.Services.GetRequiredService<IAccountManager>();
var orgManager = this.Services.GetRequiredService<IOrgManager>();
var staffManager = this.Services.GetRequiredService<IStaffManager>();
var taskManager = this.Services.GetRequiredService<ITaskManager>();
var partakerManager = this.Services.GetRequiredService<IPartakerManager>();
var reqManager = this.Services.GetRequiredService<IPartakerReqManager>();
using (var tx = TxManager.Acquire())
{
var session = sf.GetSession();
//创建任务负责人（兼审批人）的账号
var reviewerName = "Test-Account-001";
var reviewerAccount = accountManager.CreateAccount(reviewerName, reviewerName,
$"{reviewerName}@example.com", FakePhoneNumber);
//创建机构
var org = orgManager.CreateOrg(reviewerAccount, "Test-Org-001", null);
session.SaveChanges();
//创建:任务的负责人（兼审批人）对应的员工
var inviterStaff = staffManager.CreateStaff(org.Id, reviewerAccount.Id, reviewerAccount.Name);
session.SaveChanges();
orgManager.ChangeOrgAdmin(org, inviterStaff.Id);
session.SaveChanges();
//创建:申请人的账号与员工
var requestorName = "Test-Account-002";
var requestorAccount = accountManager.CreateAccount(requestorName, requestorName,
$"{requestorName}@example.com", FakePhoneNumber);
var requestorStaff = staffManager.CreateStaff(org.Id, requestorAccount.Id, requestorAccount.Name);
session.SaveChanges();
//创建任务
var taskCreationModel = new CreateTaskModel();
taskCreationModel.Name = "Test-Task-001";
taskCreationModel.Goal = taskCreationModel.Name;
taskCreationModel.CreatorStaffId = inviterStaff.Id;
var task = taskManager.CreateTask(taskCreationModel);
session.SaveChanges();
//创建申请
callback(session, reqManager, task, requestorStaff);
session.SaveChanges();
tx.NoComplete();
}
}
public async Task <IActionResult> Create([FromBody] CreateTaskModel model)
{
var response = await taskService.CreateTask(model);
return(Ok(response));
}
