public async Task <IActionResult> Post([FromBody] TaskRequest model)
{
Task newRecord = null;
if (ModelState.IsValid)
{
InitUserCredentials();
newRecord = new Task
{
Guid = Guid.NewGuid(),
UserGuid = UserGuid,
CompanyGuid = CompanyGuid,
CreationTime = DateTime.UtcNow,
CreationUserGuid = UserGuid
};
newRecord = _mapper.Map(model, newRecord);
try
{
await _taskService.Save(newRecord);
}
catch (Exception e)
{
Log.Error(e.StackTrace);
throw;
}
}
return(CreatedAtAction(nameof(Post), _mapper.Map(newRecord, new TaskResponse())));
}
private void MergeTask(Task originalTask, TaskRequest Task)
{
originalTask.Ticket = this.TicketRepository.GetById(Task.TicketId);
originalTask.Status = this.StatusRepository.GetById(Task.StatusId);
originalTask.OpenDate = Task.OpenDate;
originalTask.Priority = this.PriorityRepository.GetById(Task.PriorityId);
originalTask.Creator = this.BacklogUserRepository.GetById(Task.CreatorId);
originalTask.Description = Task.Description;
if (Task.WorkerId.HasValue)
{
originalTask.Worker = this.WorkerRepository.GetById(Task.WorkerId.Value);
}
if (Task.ProviderId.HasValue)
{
originalTask.Provider = this.ProviderRepository.GetById(Task.ProviderId.Value);
}
if (Task.ManagerId.HasValue)
{
originalTask.Manager = this.ManagerRepository.GetById(Task.ManagerId.Value);
}
if (Task.CloseDate.HasValue)
{
originalTask.CloseDate = Task.CloseDate.Value;
}
}
private IAsyncResult BeginAsync(object sender, EventArgs e, AsyncCallback cb, object state)
{
TaskRequest request = new TaskRequest()
{
TaskType = TaskTypeEnum.Email,
EmailToAddress = this.Email.Text,
EmailSubject = this.Subject.Text,
EmailMesssage = this.Body.Text
};
SqlConnection conn = new SqlConnection(ConnString);
SqlCommand cmd = new SqlCommand("[dbo].[SendTaskRequest]", conn);
cmd.CommandType = CommandType.StoredProcedure;
BinaryFormatter formatter = new BinaryFormatter();
using (MemoryStream stream = new MemoryStream())
{
formatter.Serialize(stream, request);
stream.Flush();
cmd.Parameters.Add("msg", SqlDbType.VarBinary).Value = stream.ToArray();
}
conn.Open();
IAsyncResult ar = cmd.BeginExecuteNonQuery(cb, cmd);
return(ar);
}
protected override TaskResponse Run(TaskRequest task)
{
if (string.IsNullOrEmpty(Condition))
{
throw new NullReferenceException("This step's Condition field is Empty.");
}
dynamic data = JsonConvert.DeserializeObject <dynamic>(task.Input);
var globals = new Globals {
Data = data
};
var refs = new List <MetadataReference>
{
MetadataReference.CreateFromFile(typeof(Microsoft.CSharp.RuntimeBinder.RuntimeBinderException).GetTypeInfo().Assembly.Location),
MetadataReference.CreateFromFile(typeof(System.Runtime.CompilerServices.DynamicAttribute).GetTypeInfo().Assembly.Location)
};
bool result = CSharpScript.EvaluateAsync <bool>(Condition, options: ScriptOptions.Default.AddReferences(refs), globals: globals).GetAwaiter().GetResult();
TaskResponse response = new TaskResponse
{
Status = StatusType.Complete,
ReleaseValue = result.ToString(),
Output = task.Input
};
return(response);
}
private task TraslateTaskRequestToDbTask(TaskRequest input)
{
var dbTask = new task();
var user = _commonService.GetCurrentUserContext();
var modelTask = input as TaskRequest;
if (modelTask != null)
{
dbTask.ONBOARDING_DATE = Convert.ToDateTime(modelTask.OnBoardingDate, CultureInfo.InvariantCulture);
dbTask.TASK_NAME = modelTask.TaskName;
dbTask.COMMENTS = modelTask.Comments;
dbTask.DETAILS = modelTask.Description;
dbTask.DUE_DATE = Convert.ToDateTime(modelTask.DueDate, CultureInfo.InvariantCulture);
dbTask.USER_ID = user.UserId;
dbTask.HOURS = modelTask.Hours;
dbTask.ID = modelTask.Id;
dbTask.PROJECT_NAME = modelTask.ProjectName;
dbTask.PROJECT_WBS_Code = modelTask.WBSCode;
//dbTask.REQUESTOR_EMAIL_ID = user.EmailId;
//dbTask.SKILLS = modelTask.SkillSet;
dbTask.STATUS = TaskStatus.Active.ToString();
dbTask.STATUS_DATE = DateTime.Now;
dbTask.TASK_TYPE_ID = Convert.ToInt32(modelTask.SelectedTaskType);
dbTask.SERVICE_LINE_ID = 1; //Dummy value, to suppress foreign key excption. Need to be removed once schema updated
dbTask.OFFERING_ID = Convert.ToInt32(modelTask.SelectedOffering);
if (Convert.ToDateTime(modelTask.DueDate) < DateTime.Today)
{
input.Status = dbTask.STATUS = TaskStatus.Closed.ToString();
}
}
return(dbTask);
}
public IActionResult CreateTask(TasksModel task)
{
if (ModelState.IsValid)
{
task.TaskId = Guid.NewGuid().ToString("n");
if (task.AssignedTo != null)
{
var taskId = task.TaskId;
var find = db.Users.Where(c => c.UserId == task.AssignedTo).FirstOrDefault();
TaskRequest model = new TaskRequest();
model.TaskId = taskId;
model.UserId = find.UserId;
model.RequestDate = DateTime.UtcNow;
model.DeadLine = task.DeadLine;
model.Status = "Not Confirmed";
model.Description = task.Description;
db.TaskRequests.Add(model);
db.SaveChanges();
var token = JwtToken.GenerateToken(find.UserId, taskId, find.Email);
var confirmationLink = Url.Action("ConfirmTask", "Task", new { Areas = "Administration", userId = find.UserId, token = token }, Request.Scheme);
var To = find.Email;
mailHelper.Send(To, confirmationLink);
}
db.Tasks.Add(task);
db.SaveChanges();
ViewBag.Message = "Added Succesfully";
return(RedirectToAction(nameof(ListTask)));
}
ViewBag.Message = "Cannot Process. Try Again";
return(View());
}
public ITaskRequest <TRequest> Create(IServiceBus bus)
{
var request = new TaskRequest <TRequest>(RequestId, Request, Timeout, TimeoutHandler,
CancellationToken.None, bus, Handlers);
return(request);
}
public async Task <IActionResult> Put(string id, [FromBody] TaskRequest request, [FromServices] IUpdateTaskAsync command)
{
request.SetId(id);
await _executor.ExecuteCommandAsync(command, request);
return(Ok());
}
public IActionResult UpdateTask(Guid taskId, [FromBody] TaskRequest task)
{
if (!ModelState.IsValid)
{
return(StatusCode(400, "Model is not valid"));
}
try
{
var newTask = mapper.Map <TaskDto>(task);
newTask.TaskId = taskId;
var updated = taskService.UpdateTask(newTask);
if (updated)
{
return(StatusCode(201, "Task was updated"));
}
else
{
return(StatusCode(404, "Task not found"));
}
}
catch (Exception ex)
{
return(StatusCode(500, "Internal server error"));
}
}
public Response <TaskRequest> RequestWork(WorkerRequest request)
{
Logger.Info(string.Format("RequestWork Begin {0} {1}", DateTime.Now.Ticks,
Thread.CurrentThread));
lock (_object)
{
var registration = _registry.GetRegistration(request.Token);
Assumes.NotNull(registration);
WorkItem workItem =
_repository.Query <WorkItem>().FirstOrDefault(wi => wi.Status == (WorkItemStatus.Pending));
Task task = null;
if (workItem != null)
{
task = _mappingEngine.Map <Task>(workItem);
workItem.AssignTo(registration);
_repository.Put(workItem);
}
var taskRequest = new TaskRequest {
NoWorkAvailable = task == null, Task = task
};
Logger.Info("RequestWork End " + DateTime.Now.Ticks + " " + Thread.CurrentThread);
return(new Response <TaskRequest>(true, "", taskRequest));
}
}
public async Task <ActionResult> PutAsync(Guid id, [FromBody] TaskRequest taskRequest)
{
if (id == null || id == Guid.Empty)
{
return(new BadRequestResult());
}
if (taskRequest == null)
{
return(new BadRequestResult());
}
var foundTask = await _taskService.GetByIdAync(id);
if (foundTask == null)
{
return(new NotFoundObjectResult($" {id} Not Found"));
}
foundTask.Description = taskRequest.Description;
var task = await _taskService.UpdateAsync(foundTask);
var responseTask = GetTaskResponse(task);
return(new JsonResult(responseTask));
}
public int StartBatch(string[] filenames, string environment, string username)
{
int batchId = Interlocked.Increment(ref _lastBatchId);
List <int> taskIds = new List <int>(filenames.Length);
foreach (string filename in filenames)
{
var taskRequest = new TaskRequest
{
Environment = environment,
Filename = filename,
Username = username
};
int taskId = _testFileQueue.Add(taskRequest);
taskIds.Add(taskId);
}
// cache batch info only for a limited time...
string key = $"{KeyPrefix}{batchId}";
_objectCache.Set(key, taskIds, DateTimeOffset.Now.AddHours(1));
return(batchId);
}
public TestFileRunResult RunTestFile(string filename, string environment, string username)
{
DateTime startTime = DateTime.UtcNow;
var taskRequest = new TaskRequest
{
Environment = environment,
Filename = filename,
Username = username
};
try
{
// Wait 2 minutes for the tests to run, this can be made configurable later
int taskId = Start(taskRequest);
TestFileRunnerTaskInfo task = _fileQueue.GetTestFileTaskInfo(taskId);
bool completed = task.CurrentTask.Wait(TimeSpan.FromMinutes(2));
TimeSpan timeTaken = DateTime.UtcNow - startTime;
return(_testFileResultFactory.Create(task, !completed, timeTaken));
}
catch (Exception ex)
{
TimeSpan timeTaken = DateTime.UtcNow - startTime;
// Error
return(new TestFileRunResult()
{
Finished = false,
TimeTaken = timeTaken,
ErrorMessage = ex.ToString()
});
}
}
private void Callback(TaskToBeWorked message)
{
try
{
_logger.LogDebug("Processing {0} for task {1}", message.StepType, message.TaskId);
_dal.UpdateTaskStatus(message.TaskId, StatusType.Processing);
TaskRequest request = new TaskRequest
{
TaskId = message.TaskId,
Status = StatusType.Processing,
Input = _dal.GetTaskData(message.TaskId)
};
TaskResponse response = ExecuteStep(message.StepId, message.StepType, request);
if (response.Status == StatusType.Complete)
{
_dal.ReleaseTask(message.TaskId, response.ReleaseValue, response.Output);
}
else
{
_dal.UpdateTaskStatus(message.TaskId, response.Status);
}
}
catch (Exception ex)
{
_logger.LogError(ex, "Error processing task {0}", message.TaskId);
_dal.UpdateTaskStatus(message.TaskId, StatusType.Error);
}
}
public void AddTaskResponse(string taskId, string requestId, string requestHost)
{
TaskRequest taskRequest = Repository.QueryEntities <TaskRequest>()
.Single(t => t.RequestId == requestId);
string requestJson = taskRequest.Content.FromBase64();
var requestForms = requestJson.FromJson <Dictionary <string, string> >();
string responseXml = "";
using (var httpClient = new HttpClient()) {
var httpContent = new FormUrlEncodedContent(requestForms);
var httpResponse = httpClient.PostAsync(requestHost, httpContent).Result;
httpResponse.EnsureSuccessStatusCode();
string responseString = httpResponse.Content.ReadAsStringAsync().Result;
responseXml = Uri.UnescapeDataString(responseString);
}
Repository.AddTaskResponse(requestId, responseXml, null);
dynamic response = responseXml.FromXml <dynamic>();
string responseResult = response.PaymentReturn.returnStatus;
string stateName = (responseResult == "1003" || responseResult == "1006" || responseResult == "1" ||
responseResult == "2" || responseResult == "3" || responseResult == "5" || responseResult == "120") ?
nameof(TaskStates.Completed) : nameof(TaskStates.Failed);
AddTaskState(taskId, stateName);
}
public async Task CreateTagAsync_ShouldCreteTagAndReturnTagDto()
{
// Prepare some project
var projectRequest = new ProjectRequest {
Name = "Create task project", Color = "#FF00FF"
};
var createProjectResult = await _client.CreateProjectAsync(_workspaceId, projectRequest);
createProjectResult.IsSuccessful.Should().BeTrue();
var projectId = createProjectResult.Data.Id;
var taskRequest = new TaskRequest
{
Name = "Test task",
};
var createResult = await _client.CreateTaskAsync(_workspaceId, projectId, taskRequest);
createResult.IsSuccessful.Should().BeTrue();
createResult.Data.Should().NotBeNull();
var findResult = await _client.FindAllTasksAsync(_workspaceId, projectId);
findResult.IsSuccessful.Should().BeTrue();
findResult.Data.Should().ContainEquivalentOf(createResult.Data);
}
public async Task <TaskModel[]> GetTaskList(TaskRequest task)
{
string responseString = await CallAsync(GetTaskListServiceName, JsonConvert.SerializeObject(task), MethodTypeEnum.POST, _state.userState.Token);
TaskModel[] response = JsonConvert.DeserializeObject <TaskModel[]>(responseString);
return(response);
}
protected override TaskResponse Run(TaskRequest task)
{
switch (Method)
{
case "GET":
break;
case "POST":
break;
case "PUT":
break;
case "PATCH":
break;
case "DELETE":
break;
default:
break;
}
TaskResponse result = new TaskResponse
{
Status = StatusType.Complete,
Output = task.Input
};
return(result);
}
public TaskResult create(TaskRequest taskRequest)
{
try
{
if (!verifyUser(taskRequest.connectionId))
return new TaskResult() { code = 0 };
_entity.tasks.Add(new task()
{
event_id = taskRequest.eventId,
user_id = taskRequest.userId,
created = DateTime.Now,
deadline = taskRequest.deadline,
description = taskRequest.description,
priority = taskRequest.priority
});
_entity.SaveChanges();
return new TaskResult()
{
code = 1,
eventId = taskRequest.eventId,
userId = taskRequest.userId,
created = DateTime.Now,
deadline = taskRequest.deadline,
description = taskRequest.description,
priority = taskRequest.priority
};
}
catch (Exception)
{
return new TaskResult() { code = 0 };
}
}
public ActionResult CloseTask(int id)
{
var task = this.TasksService.GetTask(id);
if (task.Status.Description != "closed")
{
var statusList = this.StatusService.GetAll();
task.Status.Id = statusList.Where(x => x.Description.Equals("closed")).FirstOrDefault().Id;
task.CloseDate = DateTime.Now;
var ntask = new TaskRequest()
{
Id = task.Id,
OpenDate = task.OpenDate,
CreatorId = task.Creator.Id,
Description = task.Description,
StatusId = task.Status.Id,
PriorityId = task.Priority.Id,
WorkerId = task.Worker != null ? task.Worker.Id : 0,
ProviderId = task.Provider != null ? task.Provider.Id : 0,
ManagerId = task.Manager != null ? task.Manager.Id : 0,
TicketId = task.Ticket.Id
};
this.TasksService.UpdateTask(ntask);
}
return(Redirect(string.Format("/Backlog/UpdateTicketById/{0}", task.Ticket.Id)));
}
public async Task DeleteTaskAsync_ShouldRemoveTask()
{
// Prepare some project
var projectRequest = new ProjectRequest {
Name = "Delete task project" + Guid.NewGuid(), Color = "#FF00FF"
};
var createProjectResult = await _client.CreateProjectAsync(_workspaceId, projectRequest);
createProjectResult.IsSuccessful.Should().BeTrue();
var projectId = createProjectResult.Data.Id;
var taskRequest = new TaskRequest
{
Name = "Test task",
};
var createResult = await _client.CreateTaskAsync(_workspaceId, projectId, taskRequest);
createResult.IsSuccessful.Should().BeTrue();
createResult.Data.Should().NotBeNull();
var findResult = await _client.FindAllTasksAsync(_workspaceId, projectId);
findResult.IsSuccessful.Should().BeTrue();
findResult.Data.Should().ContainEquivalentOf(createResult.Data);
var deleteResult = await _client.DeleteTaskAsync(_workspaceId, projectId, createResult.Data.Id);
deleteResult.IsSuccessful.Should().BeTrue();
var findResult2 = await _client.FindAllTasksAsync(_workspaceId, projectId);
findResult2.IsSuccessful.Should().BeTrue();
findResult2.Data.Should().BeEmpty();
}
public object Any(TaskRequest request)
{
DTOResponseLayUI dtoResponseLayUi = new DTOResponseLayUI();
TaskService taskService = new TaskService();
DTOResponse response;
if (request.ACTION == 100)
{
response = taskService.GetTaskList(request);
}
else if (request.ACTION == 1001)
{
response = taskService.GetTaskStepList(request);
}
else if (request.ACTION == 101)
{
response = taskService.TaskOprationByMen(request);
}
else
{
dtoResponseLayUi.code = -1;
dtoResponseLayUi.msg = "未定义的操作类型：" + request.ACTION.ToString();
return(dtoResponseLayUi);
}
return(this.ConvertTo(response));
}
public IActionResult GetTaskList(TaskRequest taskRequest)
{
using (TeamsDbEntities entities = new TeamsDbEntities())
{
List <Data.Task> taskEntity = entities.Tasks.Where(x => taskRequest.UserID.Contains(x.UserID.Value) && x.IsDelete == false && taskRequest.TeamID == x.TeamID).ToList();
List <TaskModel> taskList = new List <TaskModel>();
foreach (var task in taskEntity)
{
TaskModel tempTask = new TaskModel
{
Header = task.Header,
Detail = task.Detail,
UserID = task.UserID.Value,
Progress = (ProgressTypeEnum)Enum.ToObject(typeof(ProgressTypeEnum), task.Progress),
CreateByModel = new UserModel
{
Email = task.User1.Email,
FirstName = task.User1.FirstName,
LastName = task.User1.LastName,
ID = task.CreateBy.Value
},
CreateBy = task.CreateBy.Value,
CreateDate = task.CreateDate.Value,
StartDate = task.StartDate.Value,
EndDate = task.EndDate.Value,
ID = task.ID
};
tempTask.TaskLogs = new List <TaskLogModel>();
foreach (var tLog in task.TaskLogs)
{
tempTask.TaskLogs.Add(new TaskLogModel
{
ID = tLog.ID,
ModifyBy = tLog.ModifyBy,
UserID = tLog.UserID,
ModifyByModel = new UserModel
{
Email = tLog.User.Email,
FirstName = tLog.User.FirstName,
LastName = tLog.User.LastName,
ID = tLog.User.ID
},
UserModel = new UserModel
{
Email = tLog.User1.Email,
FirstName = tLog.User1.FirstName,
LastName = tLog.User1.LastName,
ID = tLog.User1.ID
},
ModifyDate = tLog.ModifyDate,
Progress = (ProgressTypeEnum)Enum.ToObject(typeof(ProgressTypeEnum), tLog.ProgressID),
TaskID = tLog.TaskID
});
}
taskList.Add(tempTask);
}
return(Ok(taskList.ToArray()));
}
}
public void Query()
{
var request = new TaskRequest();
if (this.State != TaskStates.All)
{
request.State = State;
}
request.CommandTypeName = this.CommandType;
var query = this.TaskService.Query(request);
// fill condition
List = query.ToList(this, x => new ListTask(x));
// commandName, descripton object
foreach (var task in List)
{
var type = Type.GetType(task.InnerObject.CommandTypeName, false, true);
if (type != null)
{
var desc = ViewModelDescriptor.GetTypeDescriptor(type);
task.CommandName = desc.Name;
}
}
// users
var userids =
List.Select(x => x.InnerObject.CreatorId).Union(List.Select(x => x.InnerObject.EditorId)).ToArray();
var users = MembershipService.GetByIds(userids).ToList();
foreach (var task in List)
{
var user = users.FirstOrDefault(x => x.UserId == task.InnerObject.CreatorId);
if (user != null)
{
task.CreatorUserName = user.DisplayName;
}
user = users.FirstOrDefault(x => x.UserId == task.InnerObject.EditorId);
if (user != null)
{
task.EditorUserName = user.DisplayName;
}
}
var accountIds =
List.Select(x => x.InnerObject.AccountId).ToArray();
var accounts = AccountService.GetByIds(accountIds);
foreach (var task in List)
{
var account = accounts.FirstOrDefault(x => x.AccountId == task.InnerObject.AccountId);
if (account != null)
{
task.AccountName = account.Name;
}
}
}
public void TaskCancelReq_Read()
{
string filepath = TestCommon.TestHelper.TestFileFolder + @"\TaskCancelRequest.xml";
var testObject = new TaskRequest(ReadFile(filepath));
Assert.AreEqual("mytask", testObject.TaskId);
Assert.AreEqual(TaskOperationType.Cancel, testObject.Operation);
}
// PUT api/<controller>/5
/// <summary>
/// Modifica un Task
/// </summary>
/// <param name="Task">Task a modificar</param>
/// <returns></returns>
public IHttpActionResult Put(int id, TaskRequest Task)
{
var originalTask = TaskService.GetById(id);
var ret = TaskService.UpdateTask(originalTask, Task);
return(Ok());
}
/// <summary>
/// Wraps call to ResolveAsync in a request
/// </summary>
virtual public Request <ResolveResultDTO <DataType> > Resolve(
Action <Request <ResolveResultDTO <DataType> > > callback = null)
{
var r = new TaskRequest <ResolveResultDTO <DataType> >(ResolveAsync());
r.Execute(callback);
return(r);
}
private void TaskUpdateReq_Create_Assert(TaskRequest testObjectIn)
{
Assert.AreEqual(1, testObjectIn.Parameters.ItemNames.Count);
Assert.IsTrue(testObjectIn.Parameters.ItemNames.Contains("myparam"));
Assert.AreEqual("myprocedure", testObjectIn.ProcedureId);
Assert.AreEqual("mytask", testObjectIn.TaskId);
Assert.AreEqual(TaskOperationType.Update, testObjectIn.Operation);
}
public async Task <IHttpActionResult> Post(TaskRequest request)
{
Log.Info($"Received task {request.TaskJson}");
IHttpActionResult result = await HandleTask(request);
Log.Info("Done");
return(result);
}
public IHttpActionResult Complete(TaskRequest model)
{
_taskBusiness.Complete(model);
var tasks = _taskBusiness.GetAllTasks();
return(Ok(tasks));
}
public IHttpActionResult Post(TaskRequest Task)
{
var result = TaskService.CreateTask(Task);
return(Created <Entidad>("", new Entidad {
Id = result.Id
}));
}
private static bool RecoursiveCheckGraph(TaskRequest root, ImmutableList<Guid> previousTasks)
{
if (previousTasks.Contains(root.Id))
return false;
foreach (var task in root.Dependencies)
{
if (previousTasks.Contains(task.Id))
return false;
if (!RecoursiveCheckGraph(task, previousTasks.Add(root.Id)))
return false;
}
return true;
}
public TaskActionResult Execute(TaskRequest taskRequest)
{
var taskType = this.GetType();
var actionMethods = taskType.GetMethods().Where(m => m.Name == taskRequest.ActionName);
var actionMethod = actionMethods.SingleOrDefault(m => m.GetParameters().All(p => taskRequest.ContentData.ContainsKey(p.Name)));
if (actionMethod == null)
{
throw new Exception(string.Format("No action named {0} on {1} has the correct parameters", taskRequest.ActionName, taskRequest.TaskName));
}
try
{
var parameters = actionMethod.GetParameters().Select(p => taskRequest.ContentData[p.Name]).Cast<object>().ToArray();
return actionMethod.Invoke(this, parameters) as TaskActionResult;
}
catch (Exception ex)
{
return new ErrorResult(ex);
}
}
public override void Execute(TaskRequest taskRequest, TaskContext context)
{
context.Storage.ActionResult(taskRequest.Id, m_Result);
}
public abstract void Execute(TaskRequest taskRequest,TaskContext context);
public override void Execute(TaskRequest taskRequest, TaskContext context)
{
context.Storage.ActionError(taskRequest.Id, Exception);
}
public IEnumerable<TaskRequest> GetTasks(int id, int userId, int count = 1,
TaskRequest.Filter filter = TaskRequest.Filter.Remaining, TaskRequest.Type type = TaskRequest.Type.Both)
{
// GET: api/Study/4/Task?userId=5&count=1&filter=Remaining&type=Review
throw new NotImplementedException();
}
public IEnumerable<int> GetTaskIDs(int id, int userId, TaskRequest.Filter filter = TaskRequest.Filter.Editable,
TaskRequest.Type type = TaskRequest.Type.Both)
{
// GET: api/Study/4/TaskIDs?userId=5&filter=Editable
throw new NotImplementedException();
}
