public void GivenIHaveAValidAddTaskForAParticipantInAConferenceRequest(Scenario scenario)
{
var conferenceId = _context.Test.Conference.Id;
var participantId = _context.Test.Conference.Participants.First(x => x.UserRole == UserRole.Individual).Id;
var addTaskRequest = new AddTaskRequest
{
ParticipantId = participantId, Body = "Witness dismissed",
TaskType = Contract.Enums.TaskType.Participant
};
switch (scenario)
{
case Scenario.Valid:
break;
case Scenario.Invalid:
conferenceId = Guid.NewGuid();
break;
default:
throw new ArgumentOutOfRangeException(nameof(scenario), scenario, null);
}
_context.Uri = AddTask(conferenceId);
_context.HttpMethod = HttpMethod.Post;
var jsonBody = RequestHelper.Serialise(addTaskRequest);
_context.HttpContent = new StringContent(jsonBody, Encoding.UTF8, "application/json");
}
public void AddTask(AddTaskRequest addTaskRequest)
{
var toAdd = new ApplicationCore.Entities.Task
{
Name = addTaskRequest.Name,
Date = addTaskRequest.Date
};
if (addTaskRequest.DependencyId == 0)
{
taskRepository.Add(toAdd);
}
else
{
var parent = taskRepository.GetById(addTaskRequest.DependencyId);
if (parent.DependencyTasks == null)
{
parent.DependencyTasks = new List <Task>();
}
parent.DependencyTasks.Add(toAdd);
taskRepository.Update(parent);
}
}
public void addTaskRequestAndTaskTypeIfNotExists(AddTaskRequest taskRequest, Task taskType)
{
using var connection = new SqlConnection(ConnectionString);
using var command = new SqlCommand
{
Connection = connection
};
using var tran = connection.BeginTransaction();
try
{
if (!ExistsInDb(taskType, command))
{
AddToTaskTypeToDb(taskType, command);
}
AddTaskRequestToDb(taskRequest, taskType, command);
tran.Commit();
}
catch (SqlException e)
{
tran.Rollback();
throw e;
}
}
public void GivenTaskWithoutDescriptionAndNoPreviousTaskWhenAddTaskThenTaskIsNotPersisted()
{
AddTaskRequest request = GivenTaskWithoutDescriptionAndNoPreviousTask();
WhenAddTask(request);
ThenTaskIsNotPersisted(request);
}
public Response <string> AddNewTask(AddTaskRequest request)
{
try
{
int affectedRows = _tasksRepository.AddNewTask(new Task
{
Title = request.Title,
Description = request.Description,
ExpirationDate = request.ExpirationDate,
Type = request.Type,
CreateDate = DateTime.Now,
Status = request.Status,
User = _usersRepository.GetAllUsers(u => u.Hash == request.UserHash).FirstOrDefault()
});
return(affectedRows == 1
? Response <string> .Succeeded("Dodano nowy task dla użytkownika " + request.UserHash)
: Response <string> .Failed());
}
catch (Exception ex)
{
_logger.LogCritical(ex.ToString());
return(Response <string> .Failed());
}
}
public void GivenADescriptionAndValidDateWhenAddTaskThenTaskIsPersisted()
{
AddTaskRequest request = GivenADescriptionAndValidDate();
WhenAddTask(request);
ThenTaskIsPersisted(request);
}
private void WhenAddTask(AddTaskRequest request)
{
IToDoTaskRepository toDoTaskRepository = new ToDoTaskRepository(path);
AddTaskUseCase useCase = new AddTaskUseCase(toDoTaskRepository);
useCase.Add(request);
}
public void GivenTaskWithPastDateWhenAddTaskThenTaskIsNotPersisted()
{
AddTaskRequest givenTask = GivenTaskWithPastDate();
WhenAddTask(givenTask);
ThenTaskIsNotPersisted(givenTask);
}
void Awake()
{
Finished = Resources.Load <Sprite>("Sprites/Finished");
UnFinished = Resources.Load <Sprite>("Sprites/UnFinished");
UnConfirmed = Resources.Load <Sprite>("Sprites/UnConfirmed");
addPanel = transform.Find("AddPanel").gameObject;
addPanel.SetActive(false);
confirmPanel = transform.Find("ConfirmPanel").gameObject;
confirmPanel.SetActive(false);
layout = transform.Find("ScrollPanel/Layout");
confirmTaskRequest = GetComponent <ConfirmTaskRequest>();
addTaskRequest = GetComponent <AddTaskRequest>();
updateTaskRequest = GetComponent <UpdateTaskRequest>();
deleteTaskRequest = GetComponent <DeleteTaskRequest>();
transform.Find("BackButton").GetComponent <Button>().onClick.AddListener(Back);
transform.Find("EditButton").GetComponent <Button>().onClick.AddListener(Edit);
EditButtonText = transform.Find("EditButton").GetComponent <Text>();
addButton = transform.Find("AddButton").gameObject;
addButton.GetComponent <Button>().onClick.AddListener(ShowAddPanel);
transform.Find("ConfirmPanel/Panel/YesButton").GetComponent <Button>().onClick.AddListener(FinishTask);
transform.Find("ConfirmPanel/Panel/NoButton").GetComponent <Button>().onClick.AddListener(UnFinishTask);
addPanel.transform.Find("Panel/SaveButton").GetComponent <Button>().onClick.AddListener(Add);
content = addPanel.transform.Find("Panel/Content").GetComponent <InputField>();
taskText = transform.Find("Task/TaskText").GetComponent <Text>();
fillImage = transform.Find("Task/FillImage").GetComponent <Image>();
score = fillImage.transform.Find("Score").GetComponent <Text>();
}
public async Task Should_fail_validation_if_body_is_empty()
{
var request = new AddTaskRequest {
TaskType = VideoApi.Domain.Enums.TaskType.Participant, Body = ""
};
var result = await _validator.ValidateAsync(request);
result.IsValid.Should().BeFalse();
}
public async Task Should_fail_validation_if_participant_is_empty()
{
var request = new AddTaskRequest {
ParticipantId = Guid.Empty, TaskType = TaskType.Participant, Body = "alert name"
};
var result = await _validator.ValidateAsync(request);
result.IsValid.Should().BeFalse();
}
public async Task Should_pass_validation()
{
var request = new AddTaskRequest {
ParticipantId = Guid.NewGuid(), TaskType = VideoApi.Domain.Enums.TaskType.Participant, Body = "alert name"
};
var result = await _validator.ValidateAsync(request);
result.IsValid.Should().BeTrue();
}
public async Task Invalid_Task_Returns_Bad_Request_Response()
{
await _testFixture.ResetDatabase();
var request = new AddTaskRequest("1", " ");
var response = await _client.AddTask(request);
response.StatusCode.ShouldBe(HttpStatusCode.BadRequest);
response.Headers.Location.ShouldBeNull();
}
public async Task Valid_AddTask_Returns_Created_Response()
{
await _testFixture.ResetDatabase();
var request = new AddTaskRequest("1", "First Task");
var response = await _client.AddTask(request);
response.StatusCode.ShouldBe(HttpStatusCode.Created);
response.Headers.Location.ShouldNotBeNull();
}
public async Task <IActionResult> PostTask([FromServices] IMediator eventor, Guid projectId,
AddTaskRequest request,
CancellationToken cancellationToken)
{
request.ProjectId = projectId;
return(await eventor.SendStream <AddTaskRequest, AddTaskResponse>(
request,
x => x.Result,
cancellationToken));
}
private AddTaskRequest GivenTaskWithPastDate()
{
string description = "Esta es una descripción";
DateTime pastDate = DateTime.Now.AddDays(-1);
AddTaskRequest addTaskRequest = new AddTaskRequest {
Description = description, DueDate = pastDate
};
return(addTaskRequest);
}
public async Task <AddTaskResponse> Add([FromBody] AddTaskRequest request)
{
var response = await _taskRepository.AddAsync(
Domain.Task.CreateInstance(
request.Name,
request.AssignedTo
));
return(new AddTaskResponse());
}
public AddTaskResponse AddTask(AddTaskRequest request)
{
using (var client = new SqlConnection("Data Source=db-mssql;Initial Catalog=s18730;Integrated Security=True"))
using (var com = new SqlCommand())
{
client.Open();
var transaction = client.BeginTransaction("AddAnimal");
try
{
com.Connection = client;
com.Transaction = transaction;
Debug.WriteLine(request.TaskType.name);
com.CommandText = "SELECT * FROM TaskType WHERE idTaskType = @idType";
com.Parameters.AddWithValue("idType", request.TaskType.idTaskType);
var dr = com.ExecuteReader();
if (!dr.Read())
{
dr.Close();
com.CommandText = "INSERT INTO TaskType VALUES (@idType, @typeName)";
com.Parameters.AddWithValue("typeName", request.TaskType.name);
}
com.CommandText = "INSERT INTO Task VALUES (@name, @description, @deadline, @idTeam, @TaskType, @idAssignedTo, @idCreator)";
com.Parameters.AddWithValue("name", request.name);
com.Parameters.AddWithValue("description", request.description);
com.Parameters.AddWithValue("deadline", request.deadline);
com.Parameters.AddWithValue("idTeam", request.IdTeam);
com.Parameters.AddWithValue("TaskType", request.TaskType.idTaskType);
com.Parameters.AddWithValue("idAssignedTo", request.IdAssignedTo);
com.Parameters.AddWithValue("idCreator", request.IdCreator);
//wyrzuca do catcha na lini niżej. Nie wiem czemu i nie mam czasu na poprawienie
com.ExecuteNonQuery();
transaction.Commit();
var response = new AddTaskResponse()
{
name = request.name,
description = request.description,
deadline = request.deadline
};
return(response);
}
catch (SqlException exception)
{
transaction.Rollback();
throw new ArgumentException("Parameter is null", "original");
}
}
}
private void ThenTaskIsPersisted(AddTaskRequest request)
{
string text = System.IO.File.ReadAllText(path);
ToDoTask todoTask = JsonConvert.DeserializeObject <ToDoTask>(text);
string insertedDescription = todoTask.Description;
DateTime insertedDueDate = todoTask.DueDate;
Assert.AreEqual(insertedDescription, request.Description);
Assert.AreEqual(insertedDueDate, request.DueDate);
}
public IActionResult AddTask(AddTaskRequest request)
{
try
{
return(Ok(_service.AddTask(request)));
}
catch (SqlException)
{
return(NotFound("blad sql")); //tak wiem ale nwm jak inaczej bo jest za pozno pewnie trza w tej metodzie
}
}
public IActionResult Post(AddTaskRequest requestObj)
{
var taskModel = new TaskToDoModel()
{
Id = Guid.NewGuid(), Active = true, Nome = requestObj.Nome
};
taskRepo.Adicionar(taskModel);
return(Ok(taskModel));
}
public IActionResult AddNewTask([FromBody] AddTaskRequest request)
{
_context.Deals.Add(new TodoDeal
{
DateTime = request.DateTime,
Priority = request.Priority,
TaskName = request.TaskName
});
_context.SaveChanges();
return(Ok());
}
//public class StaticWrapper : IStaticWrapper
//{
// public Task SendAsync(IClientProxy iClientProxy, string method, object arg1, CancellationToken cancellationToken = default)
// {
// return ClientProxyExtensions.SendAsync(iClientProxy, method, arg1, cancellationToken);
// }
//}
//public interface IStaticWrapper
//{
// Task SendAsync(IClientProxy iClientProxy, string method, object arg1, CancellationToken cancellationToken = default);
//}
//public class WrapperMethod
//{
// readonly IStaticWrapper _wrapper;
// public WrapperMethod(IStaticWrapper wrapper)
// {
// _wrapper = wrapper;
// }
// public Task SendAsync(IClientProxy iClientProxy, string method, object arg1, CancellationToken cancellationToken = default)
// {
// var value = _wrapper.SendAsync(iClientProxy, method, arg1, cancellationToken);
// return value;
// }
//}
//private class TestWrapper : IStaticWrapper
//{
// public Task SendAsync(IClientProxy iClientProxy, string method, object arg1, CancellationToken cancellationToken = default)
// {
// realisation???;
// }
//}
//[Fact]
public async void AddTask_WhenTaskWithTwoParameters_ReturnsCorrectTasks()
{
var createdAt = DateTime.UtcNow;
var mockTaskRequest = new AddTaskRequest
{
Title = "Test",
Content = "Test task",
};
var mockTaskFullRequest = new AddTaskFullRequest
{
Title = "Test",
Content = "Test task",
CreatedAt = createdAt
};
var mockTaskResponse = new TaskGetResponse
{
TaskId = 1,
Title = "Test",
Content = "Test task",
CreatedAt = createdAt,
IsDone = false
};
var mockDataRepository = new Mock <IDataRepository>();
mockDataRepository
.Setup(repo => repo.AddTask(It.IsAny <AddTaskFullRequest>()))
.Returns(() => Task.FromResult(It.IsAny <TaskGetResponse>()));
var mockClientProxy = new Mock <IClientProxy>();
var mockHubContext = new Mock <IHubContext <TasksHub> >();
mockHubContext
.Setup(hub => hub.Clients.Group(It.IsAny <string>()).SendAsync(It.IsAny <string>(), It.IsAny <Task <TaskGetResponse> >(), It.IsAny <CancellationToken>()))
.Returns(It.IsAny <Task>());
var tasksController = new TasksController(
mockDataRepository.Object, mockHubContext.Object, null, null);
var result = await tasksController.AddTask(mockTaskRequest);
var actionResult =
Assert.IsType <
ActionResult <TaskGetResponse>
>(result);
var taskResult =
Assert.IsType <TaskGetResponse>(actionResult.Value);
Assert.Equal(mockTaskResponse, taskResult);
}
public IActionResult Post([FromBody] AddTaskRequest request)
{
var task = new Tarefa(request.Nome);
using (var db = new LiteDatabase("banco.db"))
{
var taskCollection = db.GetCollection <Tarefa>("tarefas");
taskCollection.Insert(task);
}
return(Ok(new { Tarefa = task, Mensagem = "Operação realizada com sucesso!" }));
}
private void AddTaskRequestToDb(AddTaskRequest taskRequest, Task taskType, SqlCommand command)
{
command.CommandText =
"INSERT INTO 18511.dbo.Task(Name, Description, Deadline, IdProject, IdTaskType, IdAssignedTo, IdCreator) VALUES (@name,@description,@idProject,@idTaskType,@idAssignedTo,@idCreator,@Deadline)";
command.Parameters.AddWithValue("name", taskRequest.Name);
command.Parameters.AddWithValue("description", taskRequest.Description);
command.Parameters.AddWithValue("idProject", taskRequest.IdProject);
command.Parameters.AddWithValue("idTaskType", taskType.IdTaskType);
command.Parameters.AddWithValue("IdAssignedTo", taskRequest.IdAssignedTo);
command.Parameters.AddWithValue("IdCreator", taskRequest.IdCreator);
command.Parameters.AddWithValue("Deadline", taskRequest.Deadline.ToString(CultureInfo.CurrentCulture));
}
public JsonResult Add(AddTaskRequest request)
{
try
{
var response = _serviceTask.Add(request);
return(Response(response, _serviceTask));
}
catch (Exception ex)
{
return(ResponseException(ex));
}
}
public async Task When_Task_Exists_Returns_Task()
{
await _testFixture.ResetDatabase();
var addTaskRequest = new AddTaskRequest("1", "First Task");
await _client.AddTask(addTaskRequest);
var response = await _client.GetTask(new GetTaskRequest("1"));
response.TaskId.ShouldBe("1");
response.Title.ShouldBe("First Task");
}
public ResponseBase <AddTaskResponse> AddTaskInfo(AddTaskRequest req)
{
var task = taskrep.FindSingle(x => x.taskname == req.TaskName && x.isdel == 0);
if (task != null)
{
return(ResponseToClient <AddTaskResponse>(ResponesStatus.Failed, "当前任务名称已存在"));
}
DateTime dt = DateTime.Now;
int taskid = taskrep.AddTask(new tb_task()
{
createby = int.Parse(string.IsNullOrEmpty(req.AdminId)?"0":req.AdminId),
createtime = dt,
groupid = req.GroupId,
isdel = 0,
taskclassname = req.TaskMainClassName,
taskdescription = req.TaskDescription,
taskname = req.TaskName,
tasknamespace = req.TaskNameSpace,
taskremark = string.IsNullOrEmpty(req.TaskRemark)?"":req.TaskRemark,
taskschedulestatus = (int)TaskScheduleStatus.NoSchedule,
alarmtype = req.AlarmType,
alarmuserid = req.AlarmUserId,
isenablealarm = req.IsEnabledAlarm,
tasktype = req.TaskType
});
if (taskid <= 0)
{
return(ResponseToClient <AddTaskResponse>(ResponesStatus.Failed, "添加任务失败"));
}
taskversionrep.Add(new tb_taskversion()
{
nodeid = req.NodeId,
taskcreatetime = dt,
taskcron = (req.TaskType == (int)TaskType.SchedulingTask?req.TaskCorn:"[simple,,1,,]"),
taskerrorcount = 0,
tasklastendtime = Convert.ToDateTime("2099-12-30"),
tasklasterrortime = Convert.ToDateTime("2099-12-30"),
tasklaststarttime = Convert.ToDateTime("2099-12-30"),
taskparams = string.IsNullOrEmpty(req.TaskParams)?"":req.TaskParams,
taskruncount = 0,
taskrunstatus = (int)ExecuteStatus.NoExecute,
taskupdatetime = dt,
version = 1,
versioncreatetime = dt,
zipfile = req.TaskDll,
zipfilename = req.TaskDllFileName,
taskid = taskid
});
return(ResponseToClient <AddTaskResponse>(ResponesStatus.Success, "添加任务成功"));
}
public string AddTask(AddTaskRequest request)
{
using (var con = new SqlConnection(connectionS))
using (var com = new SqlCommand())
{
com.Connection = con;
con.Open();
var tran = con.BeginTransaction();
com.Transaction = tran;
com.CommandText = "SET IDENTITY_INSERT Task ON INSERT INTO Task( Name, Descripton, Deadline, IdProject ,IdTaskType, IdAssignedTo, IdCreator)" +
"VALUES(@IdAnimal, @Name, @Type, @AdmissionDate , @IdOwner)";
com.Parameters.AddWithValue("Name", request.Name);
com.Parameters.AddWithValue("Description", request.Name);
com.Parameters.AddWithValue("Deadline", request.DeadLine);
com.Parameters.AddWithValue("IdProject", request.IdProject);
com.Parameters.AddWithValue("IdTaskType", request.IdTaskType);
com.Parameters.AddWithValue("IdAssignedTo", request.IdAssignedTo);
com.Parameters.AddWithValue("IdCreatore", request.IdCreator);
Console.WriteLine("Dodano taska do bazy"); //why to sie nie wyswitle ?
com.ExecuteNonQuery();
//tran.Commit();
com.CommandText = "select IdTaskType from TaskType where IdTaskType=@IdTaskType";
com.Parameters.AddWithValue("IdTaskType", request.IdTaskType);
var dr = com.ExecuteReader();
if (!dr.Read())
{
com.CommandText = "INSERT INTO TaskType(IdTaskType, Name) VALUES(@IdTaskType, @Name)";
com.Parameters.AddWithValue("IdTaskTypee", request.IdTaskType);
com.Parameters.AddWithValue("Name", request.Name);
dr.Close();
com.ExecuteNonQuery();
}
else
{
dr.Close();
//tran.Rollback();
}
tran.Commit();
con.Close(); //potrzbne ?
return("sprawdz");
}
}
public IActionResult AddTask(AddTaskRequest taskRequest, Task taskType)
{
try
{
_service.addTaskRequestAndTaskTypeIfNotExists(taskRequest, taskType);
}
catch (SqlException e)
{
return(BadRequest(e.Message));
}
return(Ok("New task was added to database"));
}
