public static List <PatientTask> GetTasks(GetTasksRequest request)
{
List <PatientTask> tasks = null;
try
{
//[Route("/{Context}/{Version}/{ContractNumber}/Goal/Tasks", "POST")]
IRestClient client = new JsonServiceClient();
string url = Common.Helper.BuildURL(string.Format("{0}/{1}/{2}/{3}/Goal/Tasks", DDPatientGoalsServiceUrl, "NG", request.Version, request.ContractNumber), request.UserId);
GetPatientTasksDataResponse ddResponse = client.Post <GetPatientTasksDataResponse>(url, new GetPatientTasksDataRequest
{
Context = "NG", ContractNumber = request.ContractNumber, Version = request.Version, UserId = request.UserId, StatusIds = request.StatusIds, PatientId = request.PatientId
} as object);
if (ddResponse != null && ddResponse.TasksData != null)
{
tasks = new List <PatientTask>();
List <PatientTaskData> dataList = ddResponse.TasksData;
foreach (PatientTaskData n in dataList)
{
//Make a call to AttributeLibrary to get attributes details for Goal and Task.
List <CustomAttribute> taskAttributesLibrary = GoalsEndpointUtil.GetAttributesLibraryByType(request, 2);
PatientTask i = GoalsUtil.ConvertToTask(n, taskAttributesLibrary);
tasks.Add(i);
}
}
}
catch
{
throw;
}
return(tasks);
}
public async Task <GetTasksResponse> GetTasks(GetTasksRequest request)
{
Ensure.NotNull(request);
var user = _userService.Get(GetUserId());
return(await _jiraService.GetTasks(request));
}
public HttpResponseMessage Get([FromUri] TaskQueryParam options)
{
var request = new GetTasksRequest {
QueryParams = options
};
var response = _taskService.GetTasks(request);
return(_responseBuilder.BuildResponse(Request, response));
}
public ActionResult Index()
{
var tasksRequest = new GetTasksRequest
{
QueryParams = new TaskQueryParam
{
Include = new TaskQueryParam.IncludeOptions
{
User = true
},
Sort = new TaskQueryParam.SortOptions
{
Latest = true,
},
Pagination = new PaginationOptions
{
Limit = 5
}
}
};
var tasksResponse = _taskService.GetTasks(tasksRequest);
HandleServiceException(tasksResponse);
var usersRequest = new GetUsersRequest
{
QueryParams = new UserQueryParam
{
Sort = new UserQueryParam.SortOptions
{
Latest = true
},
Pagination = new PaginationOptions
{
Limit = 5
}
}
};
var usersResponse = _userService.GetUsers(usersRequest);
HandleServiceException(usersResponse);
var viewModel = new IndexViewModel
{
RecentTasks = tasksResponse.Result,
RecentUsers = usersResponse.Result,
TasksLimit = tasksRequest.QueryParams.Pagination.Limit.Value,
UsersLimit = usersRequest.QueryParams.Pagination.Limit.Value
};
return(View(viewModel));
}
public async Task <GetTasksResponse> GetTasks(GetTasksRequest request)
{
var @params = new Requests.get_tasks();
if (null != request)
{
CopyPropertiesFrom(@params, request);
}
var result = await Omp.QueryAsync <Responses.get_tasks_response>(this.Address, @params);
return(result?.Beautify());
}
public GetTasksResponse GetTasks(GetTasksRequest request)
{
try
{
GetTasksResponse response = new GetTasksResponse();
response.Tasks = GoalsEndpointUtil.GetTasks(request);
response.Version = request.Version;
return(response);
}
catch (WebServiceException ex)
{
throw new WebServiceException("AD:GetTasks()::" + ex.Message, ex.InnerException);
}
}
public GetTasksResponse GetTasks(GetTasksRequest request)
{
var response = new GetTasksResponse();
try
{
var tasks = _taskRepository.Find(request.QueryParams);
response.Result = _taskMapper.ConvertToDTO(tasks);
}
catch (Exception ex)
{
response.Exception = ex;
}
return(response);
}
public void GetTasks_Test()
{
GetTasksRequest request = new GetTasksRequest();
request.ContractNumber = "InHealth001";
request.Version = 1;
request.StatusIds = new List <int> {
1, 2, 3
};
request.PatientId = "543c2e6b84ac050980224c50";
request.UserId = "531f2df5072ef727c4d2a3bc";
GoalsManager gManager = new GoalsManager();
GetTasksResponse response = gManager.GetTasks(request);
Assert.IsNotNull(response);
}
public void GetTasksTest()
{
var mockService = new Mock <ITaskService>();
var mockLogger = new Mock <ILoggingService>();
var mockEmail = new Mock <IEmailService>();
var mockConfig = new Mock <IAppConfig <IServiceConfigOptions> >();
var service = new EnrichedTaskService(mockService.Object, mockLogger.Object, mockEmail.Object,
mockConfig.Object);
var request = new GetTasksRequest();
service.GetTasks(request);
mockService.Verify(x => x.GetTasks(request), Times.Once);
}
public JsonResult GetXTasks([FromBody] GetTasksRequest request)
{
try
{
var listOfTasks = tasksService.getTasks(request.numberOfTasks, request.listTags, request.pageNumber, request.columnToSearch, request.keyword);
if (listOfTasks != null)
{
return(new JsonResult(listOfTasks));
}
else
{
return(new JsonResult(false));
}
}
catch (Exception e)
{
Log.Error(String.Concat("Failed to get tasks : ", e.Message));
return(new JsonResult(false));
}
}
public IActionResult GetAll(Guid projectId, [FromQuery] GetTasksRequest filterOptions)
{
var user = _userRepository.GetById(GetUserId());
if (user == null)
{
return(NotFound("User not found."));
}
var project = user.Projects.FirstOrDefault(x => x.Id.Equals(projectId));
if (project == null)
{
return(NotFound("Project not found."));
}
var response = ApplyFilters(filterOptions, project.Tasks);
return(Ok(response));
}
private PagedResult <ProjectTaskViewModel> ApplyFilters(GetTasksRequest filterOptions, IEnumerable <ProjectTask> taskList)
{
var pagedResult = new PagedResult <ProjectTaskViewModel>()
{
CurrentPage = filterOptions.PageIndex, PageSize = filterOptions.PageSize, RowCount = 0
};
if (taskList.IsNullOrEmpty())
{
return(pagedResult);
}
if (filterOptions.IsCompleted.HasValue)
{
taskList = taskList.Where(x => x.IsCompleted == filterOptions.IsCompleted.Value);
}
if (filterOptions.IsImportant.HasValue)
{
taskList = taskList.Where(x => x.IsImportant == filterOptions.IsImportant.Value);
}
if (filterOptions.DeadlineRange.Min.HasValue)
{
taskList = taskList.Where(x => x.Deadline >= filterOptions.DeadlineRange.Min.Value);
}
if (filterOptions.DeadlineRange.Max.HasValue)
{
taskList = taskList.Where(x => x.Deadline <= filterOptions.DeadlineRange.Max.Value);
}
pagedResult.RowCount = taskList.Count();
pagedResult.PageCount = (int)Math.Ceiling((double)pagedResult.RowCount / pagedResult.PageSize);
taskList = taskList
.Skip((filterOptions.PageIndex - 1) * filterOptions.PageSize)
.Take(filterOptions.PageSize).ToList();
pagedResult.Results = _mapper.Map <List <ProjectTaskViewModel> >(taskList);
return(pagedResult);
}
public ActionResult Index()
{
var serviceRequest = new GetTasksRequest
{
QueryParams = new Domain.Task.QueryParams.TaskQueryParam
{
Include = new Domain.Task.QueryParams.TaskQueryParam.IncludeOptions
{
User = true
}
}
};
var serviceResponse = _taskService.GetTasks(serviceRequest);
HandleServiceException(serviceResponse);
return(View(new IndexViewModel
{
Tasks = serviceResponse.Result
}));
}
public GetTasksResponse Post(GetTasksRequest request)
{
GetTasksResponse response = new GetTasksResponse();
GoalsManager gm = new GoalsManager();
ValidateTokenResponse result = null;
try
{
request.Token = base.Request.Headers["Token"] as string;
result = Security.IsUserValidated(request.Version, request.Token, request.ContractNumber);
if (result.UserId.Trim() != string.Empty)
{
request.UserId = result.UserId;
response = gm.GetTasks(request);
}
else
{
throw new UnauthorizedAccessException();
}
}
catch (Exception ex)
{
CommonFormatter.FormatExceptionResponse(response, base.Response, ex);
if ((ex is WebServiceException) == false)
{
gm.LogException(ex);
}
}
finally
{
if (result != null)
{
AuditHelper.LogAuditData(request, result.SQLUserId, null, System.Web.HttpContext.Current.Request, request.GetType().Name);
}
}
return(response);
}
public GetTasksResponse GetTasks(GetTasksRequest request)
{
return(_innerService.GetTasks(request));
}
public override async Task <TaskPageModel> GetTasks(GetTasksRequest getTasksRequest, ServerCallContext context)
{
var getTasks = _mapper.Map <GetTasksRequest, GetTasks>(getTasksRequest);
return(_mapper.Map <PageModel <TaskModel>, TaskPageModel>(await _mediator.Send(getTasks)));
}
public void GetTasksTest()
{
var tasksRequest = new GetTasksRequest();
var task1 = new Domain.Task.Task {
Id = Guid.NewGuid(),
Name = "test",
Time = DateTime.Now,
User = new Domain.User.User {
Id = Guid.NewGuid(),
FirstName = "test",
LastName = "test",
Address = new Address {
Country = "UK"
}
}
};
var task2 = new Domain.Task.Task {
Id = Guid.NewGuid(),
Name = "test2",
Time = DateTime.Now,
User = new Domain.User.User {
Id = Guid.NewGuid(),
FirstName = "test2",
LastName = "test2",
Address = new Address {
Country = "UK"
}
}
};
var tasks = new List <Domain.Task.Task> {
task1,
task2
};
var mockUow = new Mock <IUnitOfWork>();
var mockRepo = new Mock <ITaskRepository>();
mockRepo.Setup(x => x.Find(It.IsAny <TaskQueryParam>())).Returns(tasks);
var mockMapper = new Mock <ITaskDtoMapper>();
mockMapper.Setup(x => x.ConvertToDTO(tasks)).Returns(new List <TaskDTO> {
new TaskDTO {
Id = task1.Id,
Name = task1.Name,
Time = task1.Time,
UserId = task1.User.Id,
UserFirstName = task1.User.FirstName,
UserLastName = task1.User.LastName
},
new TaskDTO {
Id = task2.Id,
Name = task2.Name,
Time = task2.Time,
UserId = task2.User.Id,
UserFirstName = task2.User.FirstName,
UserLastName = task2.User.LastName
}
});
var mockValidator = new Mock <IValidator <Domain.Task.Task> >();
var service = new TaskService(mockUow.Object, mockRepo.Object, mockMapper.Object, mockValidator.Object);
var response = service.GetTasks(tasksRequest);
Assert.IsNull(response.Exception);
Assert.IsNotNull(response.Result);
Assert.AreEqual(2, response.Result.Count());
var firstDto = response.Result.First();
Assert.AreEqual(task1.Id, firstDto.Id);
Assert.AreEqual(task1.User.Id, firstDto.UserId);
var lastDto = response.Result.Last();
Assert.AreEqual(task2.Id, lastDto.Id);
Assert.AreEqual(task2.User.Id, lastDto.UserId);
}
public List <PatientTask> GetTasks(GetTasksRequest request)
{
throw new NotImplementedException();
}
public GetTasksResponse Get(GetTasksRequest request)
{
return(_getTasksService.GetTaskByStatus());
}
