Пример #1
0
        public async Task ShouldGetModelForValidInformation()
        {
            var command = new CreateClassroomCommand
            {
                CreatedBy             = _adminUserId,
                TenantId              = _tenantId,
                CreateClassroomModels = new List <CreateClassroomCommandModel>
                {
                    new CreateClassroomCommandModel
                    {
                        TraineeUsersIdList = new List <int> {
                            _traineeUserId
                        },
                        TrainerUserId = _trainerUserId,
                        TrainingId    = _trainingId,
                        Name          = "testasdad"
                    }
                }
            };

            var classroomResponseModel = await _commandHandler.Handle(command, CancellationToken.None);

            Assert.Null(classroomResponseModel.Errors);

            Assert.True(classroomResponseModel.Items.Single().Count > 0);
        }
Пример #2
0
        public async Task CanCreateClassroomAsync()
        {
            var authorizedClient = SystemTestExtension.GetTokenAuthorizeHttpClient(_factory);

            var createClassroomCommand = new CreateClassroomCommand
            {
                CreateClassroomModels = new List <CreateClassroomCommandModel>
                {
                    new CreateClassroomCommandModel
                    {
                        TrainerUserId      = 1,
                        TrainingId         = 1,
                        TraineeUsersIdList = new List <int> {
                            1
                        },
                        Name = "test"
                    }
                }
            };

            var serializedClassroomCommand = JsonConvert.SerializeObject(createClassroomCommand);

            // The endpoint or route of the controller action.
            var httpResponse = await authorizedClient.PostAsync(requestUri : "/Classroom",
                                                                content : new StringContent(content: serializedClassroomCommand,
                                                                                            encoding: Encoding.UTF8,
                                                                                            mediaType: StringConstants.ApplicationJson));

            // Must be successful.
            httpResponse.EnsureSuccessStatusCode();

            Assert.True(httpResponse.IsSuccessStatusCode);
            Assert.Equal(HttpStatusCode.Created, httpResponse.StatusCode);
        }
        public async Task <Result <Unit> > Handle(CreateClassroomCommand request, CancellationToken cancellationToken)
        {
            var user = await _context.Users.SingleOrDefaultAsync(x =>
                                                                 x.UserName == _userAccessor.GetCurrentUsername());

            // Create the classroom.
            var classroom = new Classroom {
                Id               = request.Id,
                Name             = request.Name,
                DiscussionsCount = 0,
                CreatedBy        = user
            };

            _context.Classrooms.Add(classroom);

            var student = new ApplicationUserClassroom(user.Id, classroom.Id, true, user, classroom);

            _context.ApplicationUserClassrooms.Add(student);

            var success = await _context.SaveChangesAsync() > 0;

            if (!success)
            {
                return(Result <Unit> .Failure("There was a problem saving changes."));
            }

            return(Result <Unit> .Success(Unit.Value));
        }
Пример #4
0
 public void SetUp()
 {
     _repository             = new Mock <IClassroomRepository>();
     _handler                = new ClassroomHandler(_repository.Object);
     _createClassroomCommand = new CreateClassroomCommand()
     {
         DayOfWeek = DayOfWeek.Friday,
         Start     = _baseDate.AddHours(13),
         End       = _baseDate.AddHours(15),
     };
 }
Пример #5
0
        private async Task CreateClassroomAsync(HttpClient client)
        {
            const string ApiPath = "api/v1/classrooms";
            var          command = new CreateClassroomCommand(
                Guid.NewGuid(),
                Random.Next(Grade.Min, Grade.Max),
                Random.RandomString(3));

            var response = await client.PostAsync(ApiPath, command.ToJsonContent());

            response.EnsureSuccessStatusCode();
        }
Пример #6
0
        protected async Task <CreateClassroomCommand> CreateClassroomAsync(HttpClient client)
        {
            var command = new CreateClassroomCommand(
                Guid.NewGuid(),
                Random.Next(Grade.Min, Grade.Max),
                Random.RandomString(3));

            var response = await client.PostAsync(ApiPath, command.ToJsonContent());

            response.EnsureSuccessStatusCode();

            return(command);
        }
        public async Task <IActionResult> Post([FromBody] CreateClassroomCommand command)
        {
            if (command == null)
            {
                return(GenerateResponse(StatusType.Fail,
                                        null,
                                        "Invalid Parameters"
                                        ));
            }

            return(GenerateResponse(
                       StatusType.Success,
                       await _mediator.Send(command)
                       ));
        }
Пример #8
0
        private async Task <int> GetClassroomIdAsync(HttpClient client)
        {
            const string ApiPath = "api/v1/classrooms";

            var command = new CreateClassroomCommand(
                Guid.NewGuid(),
                Random.Next(Grade.Min, Grade.Max),
                Random.RandomString(3));
            var response = await client.PostAsync(ApiPath, command.ToJsonContent());

            response.EnsureSuccessStatusCode();

            response = await client.GetAsync(ApiPath);

            var list = await response.ReadAsync <IEnumerable <ClassroomReadModel> >();

            return(list.First().Id);
        }
Пример #9
0
        public async Task <ActionResult <ResponseModel <CreateClassroomModel> > > Post([FromBody] CreateClassroomCommand command)
        {
            try
            {
                command.CreatedBy = Claims[ClaimTypes.Sid].ToInt();
                command.TenantId  = Guid.Parse(Claims[ClaimTypes.UserData]);

                var createClassroomModel = await Mediator.Send(command);

                return(Created($"api/classroom/{createClassroomModel.Items}", createClassroomModel));
            }
            catch (ObjectAlreadyExistsException ex)
            {
                return(Conflict(new ResponseModel <CreateClassroomModel>(new Error(HttpStatusCode.Conflict, ex))));
            }
            catch
            {
                return(StatusCode(HttpStatusCode.InternalServerError.ToInt()));
            }
        }
Пример #10
0
 public async Task <IActionResult> Create([FromBody] CreateClassroomCommand command)
 {
     return(HandleResult(await Mediator.Send(command)));
 }
 public ICommandResult Post([FromBody] CreateClassroomCommand command)
 {
     return(_handler.Handle(command));
 }