public async Task <TaskStatusDto> PutTaskStatus(int id, TaskStatusDto model)
{
var url = CRMApiUri + "/TaskStatus/" + id;
var result = await PutRequestToApi(url, model);
return(result);
}
public async Task <BaseEntity> SaveAndReturnEntityAsync(TaskStatusDto entityDto)
{
var entity = _mapper.Map <TaskStatus>(entityDto);
var result = await _repository.SaveAndReturnEntityAsync(entity);
return(result);
}
public async Task <TaskStatusDto> PostTaskStatus(TaskStatusDto model)
{
var url = CRMApiUri + "/TaskStatus";
var result = await PostRequestToApi(url, model);
return(result);
}
public void TaskStatusDto_Extension_AsEntity_Null()
{
TaskStatusDto taskStatus = null;
var result = taskStatus.AsEntity();
Assert.IsNull(result);
Assert.AreEqual(null, result);
}
public async Task <IActionResult> Put(int id, [FromBody] TaskStatusDto taskStatus)
{
if (id == 0 || taskStatus.Id == 0)
{
return(StatusCode(StatusCodes.Status400BadRequest, "Id needs to be greater than 0."));
}
return(await SaveAndReturnEntityAsync(async() => await _taskStatusService.SaveAndReturnEntityAsync(taskStatus)));
}
public async Task <IActionResult> Post([FromBody] TaskStatusDto taskStatus)
{
if (taskStatus.Id != 0)
{
return(StatusCode(StatusCodes.Status400BadRequest, "Identity insert is not permitted."));
}
return(await SaveAndReturnEntityAsync(async() => await _taskStatusService.SaveAndReturnEntityAsync(taskStatus)));
}
public static void Create(TaskStatusDto dto)
{
using (var db = new MainDBModelContainer())
{
var entity = TaskStatusMapper.DtoToEntity(dto);
db.TaskStatusSet.Add(entity);
db.SaveChanges();
}
}
public static TaskStatus DtoToEntity(TaskStatusDto dto)
{
var entity = new TaskStatus
{
Id = dto.Id,
Name = dto.Name,
};
return(entity);
}
public void Update(TaskStatusDto dto)
{
using (UnitOfWork uow = new UnitOfWork())
{
var entity = MapperFactory.Map <TaskStatusDto, TeamWork.Data.Context.TaskStatus>(dto);
uow.GetRepository <TeamWork.Data.Context.TaskStatus>().Update(entity);
uow.SaveChanges();
}
}
public static TaskStatusDto EntityToDto(TaskStatus entity)
{
var dto = new TaskStatusDto
{
Id = entity.Id,
Name = entity.Name,
};
return(dto);
}
public static Model.TaskStatus MapFromDto(TaskStatusDto dto)
{
return(new Model.TaskStatus()
{
TaskName = dto.TaskName,
StatusText = dto.StatusText,
TaskState = ParseTaskState(dto.Status),
IsRunning = dto.IsRunning,
Errors = dto.Errors?.Select(SpaceTaskMapper.MapFromRunningTaskErrorInfoDto)?.ToList() ?? new List <ErrorInfo>()
});
}
public void TaskStatusDto_Property_IsDeleted()
{
var taskStatus = new TaskStatusDto();
var value = false;
taskStatus.IsDeleted = value;
Assert.IsNotNull(taskStatus.IsDeleted);
Assert.IsInstanceOfType(taskStatus.IsDeleted, typeof(bool));
Assert.AreEqual(value, taskStatus.IsDeleted);
}
public void TaskStatusDto_Property_Name()
{
var taskStatus = new TaskStatusDto();
var value = "Test Task Status";
taskStatus.Name = value;
Assert.IsNotNull(taskStatus.Name);
Assert.IsInstanceOfType(taskStatus.Name, typeof(string));
Assert.AreEqual(value, taskStatus.Name);
}
public void TaskStatusDto_Property_Modified()
{
var taskStatus = new TaskStatusDto();
var value = DateTime.Now;
taskStatus.Modified = value;
Assert.IsNotNull(taskStatus.Modified);
Assert.IsInstanceOfType(taskStatus.Modified, typeof(DateTime));
Assert.AreEqual(value, taskStatus.Modified);
}
public void TaskStatusDto_Property_ModifiedBy()
{
var taskStatus = new TaskStatusDto();
var value = Core.Tests.TestHelper.UserDto();
taskStatus.ModifiedBy = value;
Assert.IsNotNull(taskStatus.ModifiedBy);
Assert.IsInstanceOfType(taskStatus.ModifiedBy, typeof(UserDto));
Assert.AreEqual(value, taskStatus.ModifiedBy);
}
public void TaskStatusDto_Property_IsActive()
{
var taskStatus = new TaskStatusDto();
var value = true;
taskStatus.IsActive = value;
Assert.IsNotNull(taskStatus.IsActive);
Assert.IsInstanceOfType(taskStatus.IsActive, typeof(bool));
Assert.AreEqual(value, taskStatus.IsActive);
}
public HttpResponseMessage Post(TaskStatusDto dto)
{
try
{
if (dto != null)
{
TaskStatusRepository.Create(dto);
return(Request.CreateResponse(HttpStatusCode.OK));
}
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
catch (Exception)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, "Generic error happened."));
}
}
public IActionResult Save(TaskStatusDto model)
{
UpdateAuditInformation(model);
if (!ModelState.IsValid)
{
GetStateSettings(ViewState.Write);
return(PartialView("Edit", model));
}
model = model.Id > 0
? _lookupFacadeApiClient.PutTaskStatus(model.Id, model).Result
: _lookupFacadeApiClient.PostTaskStatus(model).Result;
if (!string.IsNullOrWhiteSpace(model.ErrorMessage))
{
return(PartialView("Edit", model));
}
return(Json(new { message = model.SuccessMessage }));
}
public static void Update(TaskStatusDto dto)
{
using (var db = new MainDBModelContainer())
{
var newData = TaskStatusMapper.DtoToEntity(dto);
var oldData = db.TaskStatusSet.Find(dto.Id);
if (oldData != null)
{
oldData.Name = newData.Name;
db.SaveChanges();
}
else
{
throw new ElementNotFoundException();
}
}
}
public static TaskStatus AsEntity(this TaskStatusDto taskStatusDto)
{
if (taskStatusDto == null)
{
return(null);
}
return(new TaskStatus
{
ID = taskStatusDto.Id,
Name = taskStatusDto.Name,
Created = taskStatusDto.Created,
CreatedBy = taskStatusDto.CreatedBy.AsEntity(),
Modified = taskStatusDto.Modified,
ModifiedBy = taskStatusDto.ModifiedBy.AsEntity(),
IsActive = taskStatusDto.IsActive,
IsDeleted = taskStatusDto.IsDeleted
});
}
public async Task <TaskStatusDto> GetTaskStatus_ApiGetAsync(Guid taskGuid)
{
string uri = baseClarinApiUri + $"/getStatus/{taskGuid}";
var client = _clientFactory.CreateClient();
var response = await client.GetAsync(uri);
var contents = await response.Content.ReadAsStringAsync();
Debug.WriteLine("****************************** GetTaskStatus_ApiGetAsync *****************************************");
Debug.WriteLine(contents);
JObject jsonResponse = JObject.Parse(contents);
TaskStatusDto taskStatus = new TaskStatusDto();
taskStatus.Status = jsonResponse["status"].ToString();
if (taskStatus.Status == "DONE")
{
taskStatus.ResultFileId = jsonResponse["value"][0]["fileID"].ToString();
}
else if (taskStatus.Status == "PROCESSING")
{
taskStatus.ProcessingValue = jsonResponse["value"].ToString();
}
else if (taskStatus.Status == "ERROR")
{
taskStatus.ErrorMessage = jsonResponse["value"].ToString();
}
else
{
taskStatus.UnknowStatus = true;
}
return(taskStatus);
}
public PaginationQueryDto Query(PaginationQueryTaskStatusInput input)
{
if (input == null)
{
throw new ArgumentNullException($"{nameof(input)} should not be null.");
}
PaginationQueryDto output;
var status = input.Status?.ToLower();
var keyword = input.Keyword?.ToLower();
List <Core.Entities.Task> tasks;
List <string> taskIds;
List <Core.Entities.TaskStatus> taskStatuses;
Expression <Func <Core.Entities.TaskStatus, bool> > where = null;
if (string.IsNullOrWhiteSpace(keyword))
{
if (!string.IsNullOrEmpty(status) && "all" != status)
{
where = d => d.Status.ToLower() == status;
}
output = DbContext.TaskStatus.PageList <Core.Entities.TaskStatus, long, long>(input, where, d => d.Id);
taskStatuses = (List <Core.Entities.TaskStatus>)output.Result;
taskIds = taskStatuses.Select(t => t.TaskId).ToList();
var ids = taskIds;
tasks = DbContext.Task.Where(t => ids.Contains(t.Id)).ToList();
}
else
{
tasks = DbContext.Task.Where(t => t.Name.ToLower().Contains(keyword)).ToList();
taskIds = tasks.Select(t => t.Id).ToList();
if (!string.IsNullOrEmpty(status) && "all" != status)
{
var ids = taskIds;
where = d => d.Status.ToLower() == status && ids.Contains(d.TaskId);
}
else
{
var ids = taskIds;
where = d => ids.Contains(d.TaskId);
}
output = DbContext.TaskStatus.PageList <Core.Entities.TaskStatus, long, long>(input, where, d => d.Id);
taskStatuses = (List <Core.Entities.TaskStatus>)output.Result;
}
var taskStatusOutputs = new List <TaskStatusDto>();
foreach (var taskStatus in taskStatuses)
{
var taskStatusOutput = new TaskStatusDto();
taskStatusOutput.Name = tasks.FirstOrDefault(t => t.Id == taskStatus.TaskId)?.Name;
taskStatusOutput.AvgDownloadSpeed = taskStatus.AvgDownloadSpeed;
taskStatusOutput.AvgPipelineSpeed = taskStatus.AvgDownloadSpeed;
taskStatusOutput.AvgProcessorSpeed = taskStatus.AvgDownloadSpeed;
taskStatusOutput.Error = taskStatus.Error;
taskStatusOutput.Identity = taskStatus.Identity;
taskStatusOutput.LastModificationTime = taskStatus.LastModificationTime?.ToString("yyyy/MM/dd HH:mm:ss");
taskStatusOutput.Left = taskStatus.Left;
taskStatusOutput.NodeId = taskStatus.NodeId;
taskStatusOutput.Status = taskStatus.Status;
taskStatusOutput.Success = taskStatus.Success;
taskStatusOutput.TaskId = taskStatus.TaskId;
taskStatusOutput.Thread = taskStatus.Thread;
taskStatusOutput.Total = taskStatus.Total;
taskStatusOutputs.Add(taskStatusOutput);
}
output.Result = taskStatusOutputs;
return(output);
}
public async Task <TaskStatusDto> PostTaskStatus(TaskStatusDto model)
{
return(await _taskStatusApiClient.PostTaskStatus(model));
}
public async Task <TaskStatusDto> PutTaskStatus(int id, TaskStatusDto model)
{
return(await _taskStatusApiClient.PutTaskStatus(id, model));
}
public void TaskStatusDto_Property_Count()
{
var taskStatus = new TaskStatusDto();
Assert.AreEqual(8, taskStatus.GetType().GetProperties().Count());
}
public async Task <int> SaveAsync(TaskStatusDto entityDto)
{
var result = await SaveAndReturnEntityAsync(entityDto);
return(result.Id);
}
