예제 #1
0
        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");
        }
예제 #2
0
        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);
            }
        }
예제 #3
0
        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;
            }
        }
예제 #4
0
        public void GivenTaskWithoutDescriptionAndNoPreviousTaskWhenAddTaskThenTaskIsNotPersisted()
        {
            AddTaskRequest request = GivenTaskWithoutDescriptionAndNoPreviousTask();

            WhenAddTask(request);
            ThenTaskIsNotPersisted(request);
        }
예제 #5
0
        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);
        }
예제 #8
0
        public void GivenTaskWithPastDateWhenAddTaskThenTaskIsNotPersisted()
        {
            AddTaskRequest givenTask = GivenTaskWithPastDate();

            WhenAddTask(givenTask);
            ThenTaskIsNotPersisted(givenTask);
        }
예제 #9
0
 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>();
 }
예제 #10
0
        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();
        }
예제 #12
0
        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();
        }
예제 #13
0
        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();
        }
예제 #14
0
        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();
        }
예제 #15
0
 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));
 }
예제 #16
0
        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);
        }
예제 #17
0
        public async Task <AddTaskResponse> Add([FromBody] AddTaskRequest request)
        {
            var response = await _taskRepository.AddAsync(
                Domain.Task.CreateInstance(
                    request.Name,
                    request.AssignedTo
                    ));

            return(new AddTaskResponse());
        }
예제 #18
0
        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);
        }
예제 #20
0
 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
     }
 }
예제 #21
0
        public IActionResult Post(AddTaskRequest requestObj)
        {
            var taskModel = new TaskToDoModel()
            {
                Id = Guid.NewGuid(), Active = true, Nome = requestObj.Nome
            };

            taskRepo.Adicionar(taskModel);

            return(Ok(taskModel));
        }
예제 #22
0
        public IActionResult AddNewTask([FromBody] AddTaskRequest request)
        {
            _context.Deals.Add(new TodoDeal
            {
                DateTime = request.DateTime,
                Priority = request.Priority,
                TaskName = request.TaskName
            });

            _context.SaveChanges();
            return(Ok());
        }
예제 #23
0
        //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);
        }
예제 #24
0
        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!" }));
        }
예제 #25
0
 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));
 }
예제 #26
0
 public JsonResult Add(AddTaskRequest request)
 {
     try
     {
         var response = _serviceTask.Add(request);
         return(Response(response, _serviceTask));
     }
     catch (Exception ex)
     {
         return(ResponseException(ex));
     }
 }
예제 #27
0
파일: GetTask.cs 프로젝트: awright18/Slice
        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, "添加任务成功"));
        }
예제 #29
0
        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");
                }
        }
예제 #30
0
      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"));
      }