public async Task <IActionResult> Put([FromBody] Edit.Command model)
        {
            await Mediator.Send(model);

            return(NoContent());
        }
Beispiel #2
0
 public async Task <ActionResult <Unit> > Edit(Guid id, Edit.Command command)
 {
     command.Id = id;
     return(await Mediator.Send(command));
 }
Beispiel #3
0
        public async Task <Edit.Response> Edit([FromBody] Edit.Command command)
        {
            var response = await _mediator.Send(command);

            return(response);
        }
Beispiel #4
0
 public async Task <ActionResult <Unit> > Add(Edit.Command command)
 {
     return(await Mediator.Send(command));
 }
 public async Task <IActionResult> EditProfile(Edit.Command command)
 {
     return(HandleResult(await Mediator.Send(command)));
 }
 public async Task <ActionResult <Unit> > Edit([FromBody] Edit.Command command, Guid id)
 {
     command.Id = id;
     return(await _mediator.Send(command));
 }
 public async Task <ActionResult <long> > Put([FromBody] Edit.Command model)
 {
     return(await Mediator.Send(model));
 }
Beispiel #8
0
        public async Task <IActionResult> Put(long id, [FromBody] Edit.Command model)
        {
            await _mediator.Send(model).ConfigureAwait(false);

            return(NoContent());
        }
 public async Task <ActionResult <Unit> > Edit(int id, Edit.Command command)
 {
     command.SubmissionId = id;
     return(await Mediator.Send(command));
 }
Beispiel #10
0
        public async Task <ActionResult> Edit(Edit.Command model)
        {
            await _mediator.SendAsync(model);

            return(this.RedirectToActionJson("Index"));
        }
 //Edit a product by id
 public async Task <ActionResult <ProductDTO> > Edit(int id, Edit.Command command)
 {
     command.Id = id;
     return(await Mediator.Send(command));
 }
        public async Task Should_edit(ContosoUniversityCore.Features.Instructor.CreateEdit.Command instructor, Department dept, Department newDept, Course course, Edit.Command command)
        {
            var adminId = await SendAsync(instructor);

            var admin = await FindAsync <Instructor>(adminId);

            dept.Administrator    = admin;
            newDept.Administrator = admin;

            course.Id         = 1234;
            course.Department = dept;

            await InsertAsync(dept, newDept, course);

            command.Id         = course.Id;
            command.Department = newDept;

            await SendAsync(command);

            var edited = await FindAsync <Course>(course.Id);

            edited.ShouldNotBeNull();
            edited.DepartmentID.ShouldBe(newDept.Id);
            edited.Credits.ShouldBe(command.Credits.GetValueOrDefault());
            edited.Title.ShouldBe(command.Title);
        }
Beispiel #13
0
        public async Task <IActionResult> Edit(Edit.Command command)
        {
            var result = await Mediator.Send(command);

            return(Ok(result));
        }
Beispiel #14
0
        public async Task Should_edit(ContainerFixture fixture)
        {
            var admin = new Instructor
            {
                FirstMidName = "George",
                LastName     = "Costanza",
                HireDate     = DateTime.Today,
            };
            await fixture.ExecuteDbContextAsync(async db =>
            {
                db.Instructors.Add(admin);
                await db.SaveChangesAsync();
            });

            var dept = new Department
            {
                Name          = "History",
                Administrator = admin,
                Budget        = 123m,
                StartDate     = DateTime.Today
            };
            var newDept = new Department
            {
                Name          = "English",
                Administrator = admin,
                Budget        = 123m,
                StartDate     = DateTime.Today
            };

            await fixture.ExecuteDbContextAsync(async db =>
            {
                db.Departments.Add(dept);
                db.Departments.Add(newDept);
                await db.SaveChangesAsync();
            });

            var course = new Course
            {
                Credits    = 4,
                Department = dept,
                CourseID   = 1234,
                Title      = "English 101"
            };

            await fixture.ExecuteDbContextAsync(async db =>
            {
                db.Courses.Add(course);
                await db.SaveChangesAsync();
            });

            var command = new Edit.Command
            {
                CourseID   = course.CourseID,
                Credits    = 5,
                Department = newDept,
                Title      = "English 202"
            };
            await fixture.SendAsync(command);

            await fixture.ExecuteDbContextAsync(async db =>
            {
                var created = await db.Courses.Where(c => c.CourseID == command.CourseID).SingleOrDefaultAsync();

                created.ShouldNotBeNull();
                created.DepartmentID.ShouldBe(newDept.DepartmentID);
                created.Credits.ShouldBe(command.Credits.GetValueOrDefault());
                created.Title.ShouldBe(command.Title);
            });
        }
Beispiel #15
0
 public async Task <ActionResult <Unit> > Edit(string Id, Edit.Command control)
 {
     control.Id = Id;
     return(await Mediator.Send(control));
 }