public void TaskCreatingWorks()
{
Guid userGuid = Guid.NewGuid();
Guid managerGuid = Guid.NewGuid();
User user = userRepositoriy.CreateUser(new User()
{
Id = userGuid, FirstName = "test_name", FamilyName = "test_family", MiddleName = "test_middlename", Level = UserLevel.Scaner, CreatedAt = DateTime.UtcNow, Login = "******", Password = "******"
});
User manager = userRepositoriy.CreateUser(new User()
{
Id = userGuid, FirstName = "test_manager_name", FamilyName = "test_manager_family", MiddleName = "test_manager_middlename", Level = UserLevel.Scaner, CreatedAt = DateTime.UtcNow, Login = "******", Password = "******"
});
Company company = companyRepositoriy.CreateCompany("Тест1");
Business.Model.Inventorization inventarisation = inventorizationRepositoriy.CreateInventorization(company.Id, DateTime.UtcNow);
Guid firstTaskId = Guid.NewGuid();
taskRepository.CreateTask(firstTaskId, managerGuid, userGuid, inventarisation.Id);
List <Business.Model.Task> tasks = taskRepository.GetTasks(userGuid, inventarisation.Id);
Assert.IsNotNull(tasks);
Assert.AreEqual(1, tasks.Count());
taskRepository.DeleteTask(firstTaskId);
inventorizationRepositoriy.DeleteInventorization(inventarisation.Id);
companyRepositoriy.DeleteCompany(company.Id);
}
public async System.Threading.Tasks.Task Get_Tasks_Returns_Tasks()
{
// Arrange
await sut.CreateTask(task);
var expectedResult = JsonConvert.SerializeObject(tasks);
// Act
var result = await sut.GetTasks(task.TenantId);
var stringResult = JsonConvert.SerializeObject(result);
// Assert
Assert.Equal(expectedResult, stringResult);
}
public void CreateJiraTasks()
{
var queries = JiraRepository.GetAllQueries();
if (queries != null)
{
foreach (var query in queries)
{
if (TaskRepository.IsPlanned(query.Id))
{
continue;
}
var latestRun = TaskRepository.GetLatestRunByReference(query.Id)?.ProcessedTime.Value ?? DateTime.Now;
if (FrequencyHelper.IsTimeToPlan(query.Frequency, latestRun, out DateTime plannedRunTime))
{
TaskRepository.CreateTask(new Task
{
Type = TaskType.JIRA,
Status = TaskStatus.PLANNED,
PlannedTime = plannedRunTime,
Reference = query.Id
});
}
}
}
}
public TaskVM CreateTask(string name, string description, string fileId)
{
var task = _repo.CreateTask(name, description, fileId);
_repo.SetTaskState(task.Id, TaskStatus.Incompleted);
var vm = _repo.FindTaskVMById(task.Id);
return(vm);
}
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 CreateTask_Correct_UseDbContextReturnCorrect()
{
TaskContext.Invocations.Clear();
var id1 = Guid.NewGuid();
var typeId1 = 1;
var statusId1 = 1;
var data1 = "123455";
var task = new Task();
var mockSet0 = new Mock <DbSet <Task> >();
var data0 = new List <Task>().AsQueryable();
mockSet0.As <IQueryable <Task> >().Setup(m => m.Provider).Returns(data0.Provider);
mockSet0.As <IQueryable <Task> >().Setup(m => m.Expression).Returns(data0.Expression);
mockSet0.As <IQueryable <Task> >().Setup(m => m.ElementType).Returns(data0.ElementType);
mockSet0.As <IQueryable <Task> >().Setup(m => m.GetEnumerator()).Returns(() => data0.GetEnumerator());
mockSet0.Setup(m => m.Add(It.IsAny <Task>()))
.Callback((Task taskParam) => { task = taskParam; });
var data = new List <Task>
{
new Task {
Id = id1, Type = typeId1, Status = statusId1, Data = data1
}
}.AsQueryable();
var mockSet = new Mock <DbSet <Task> >();
mockSet.As <IQueryable <Task> >().Setup(m => m.Provider).Returns(data.Provider);
mockSet.As <IQueryable <Task> >().Setup(m => m.Expression).Returns(data.Expression);
mockSet.As <IQueryable <Task> >().Setup(m => m.ElementType).Returns(data.ElementType);
mockSet.As <IQueryable <Task> >().Setup(m => m.GetEnumerator()).Returns(() => data.GetEnumerator());
mockSet.Setup(m => m.Add(It.IsAny <Task>()));
TaskContext.Setup(x => x.Task).Returns(mockSet.Object);
TaskContext.Setup(x => x.Set <Task>()).Returns(mockSet0.Object);
TaskContext.Setup(x => x.SaveChanges()).Returns(1);
TaskContextFactory.Setup(x => x.CreateDBContext()).Returns(TaskContext.Object);
var repository = new TaskRepository(TaskContextFactory.Object);
var result = repository.CreateTask(typeId1, statusId1, data1);
TaskContext.Verify(x => x.Set <Task>(), Times.Once);
TaskContext.Verify(x => x.SaveChanges(), Times.Once);
mockSet0.Verify(x => x.Add(It.IsAny <Task>()), Times.Once);
Assert.AreEqual(task.Type, typeId1);
Assert.AreEqual(task.Status, statusId1);
Assert.AreEqual(task.Data, data1);
}
public ActionResult Create(MyTask task)
{
try
{
taskRepository.CreateTask(task);
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public void SearchJira()
{
var jiraTask = TaskRepository.GetJiraPlanned();
if (jiraTask == null)
{
Logger.WriteInfo($"No JIRA tasks planned for the run at: { DateTime.Now.ToString(Constants.DateTimeFormat) }");
return;
}
var jiraQuery = JiraRepository.GetQueryById(jiraTask.Reference);
if (jiraQuery == null)
{
Logger.WriteError($"No JIRA query found with id: { jiraTask.Reference }");
return;
}
var success = new Action <string>((response) =>
{
TaskRepository.CreateTask(new Task
{
PlannedTime = DateTime.Now.AddMinutes(5),
Type = TaskType.MATTERMOST,
Status = TaskStatus.PLANNED,
Reference = jiraQuery.Id
});
TaskRepository.UpdateStatus(jiraQuery.Id, TaskStatus.COMPLETED);
});
var fail = new Action <string>((message) =>
{
TaskRepository.UpdateStatus(jiraQuery.Id, TaskStatus.FAILED);
Logger.WriteError(message);
});
var request = new JiraRequestManager();
request.Search(new JiraConfiguration
{
BaseAddress = "https://jira.devfactory.com",
Username = "******",
Password = "******",
ApiPath = "/rest/api/2/search",
Query = "fields=key&jql=assignee=mbigun&maxResults=10"
},
success, fail).ConfigureAwait(false);
}
public void CanStartSaveGetAndStop()
{
var taskRepository = new TaskRepository() { Configuration = new CoreConfiguration(".",".") };
var task = new Task("do stuff");
task.Start();
taskRepository.CreateTask(task);
Thread.Sleep(TimeSpan.FromSeconds(1)); // TODO: remove this sleep
var loadedTask = taskRepository.FromFileName(task.FileName);
loadedTask.Stop();
Assert.Equal(1, loadedTask.Durations.Count);
}
public async Task <ActionResult> Create(TasksWeb.Models.Task task)
{
TaskRepository repository = new TaskRepository();
if (Request.HttpMethod == "POST")
{
TasksWeb.Models.Task newTask = await repository.CreateTask(task);
return(Redirect("/"));
}
else
{
return(View(task));
}
}
public void RepositoryWorks()
{
var taskRepository = new TaskRepository() { Configuration = new CoreConfiguration(".", ".") };
var task = new Task("do stuff");
task.Start();
task.Stop();
task.Start();
task.Stop();
taskRepository.CreateTask(task);
var loadedTask = taskRepository.FromFileName(task.FileName);
Assert.Equal(task.Durations.Count, loadedTask.Durations.Count);
Assert.Equal(task.Name, loadedTask.Name);
}
public void CanStartSaveGetAndStop()
{
var taskRepository = new TaskRepository()
{
Configuration = new CoreConfiguration(".", ".")
};
var task = new Task("do stuff");
task.Start();
taskRepository.CreateTask(task);
Thread.Sleep(TimeSpan.FromSeconds(1)); // TODO: remove this sleep
var loadedTask = taskRepository.FromFileName(task.FileName);
loadedTask.Stop();
Assert.Equal(1, loadedTask.Durations.Count);
}
public void RepositoryWorks()
{
var taskRepository = new TaskRepository()
{
Configuration = new CoreConfiguration(".", ".")
};
var task = new Task("do stuff");
task.Start();
task.Stop();
task.Start();
task.Stop();
taskRepository.CreateTask(task);
var loadedTask = taskRepository.FromFileName(task.FileName);
Assert.Equal(task.Durations.Count, loadedTask.Durations.Count);
Assert.Equal(task.Name, loadedTask.Name);
}
public ActionResult <Taskk> Post([FromBody] Taskk newTask)
{
List <Taskk> tasks = repo.CreateTask(newTask);
return(Ok(tasks));
}
public async Task CreateTask(TaskDispayModel model)
{
_tasks.CreateTask(model);
}
public async Task <List <Tarefa> > CreateTask(TarefaDTO tarefa)
{
List <Tarefa> Novatarefas = await _taskRepository.CreateTask(tarefa);
return(Novatarefas);
}
public bool CreateTask(UserTaskListModel list, UserTaskModel model)
{
return(_repository.CreateTask(Mapper.MapTaskList(list), Mapper.MapUserTask(model)));
}
