public async Task <ApiResult <bool> > CreateCourse(CreateCourseRequest request)
{
if (await _context.Teachers.FindAsync(request.Id_Teacher) == null)
{
return(new ApiErrorResult <bool>("Không tìm thấy Giáo viên "));
}
if (await _context.Subjects.FindAsync(request.Id_Subject) == null)
{
return(new ApiErrorResult <bool>("Không tìm thấy Môn học phù hợp "));
}
var subject = await _context.Subjects.FindAsync(request.Id_Subject);
var course = new Course()
{
Id_Subject = request.Id_Subject,
Id_Teacher = request.Id_Teacher,
Name = request.Name,
Semester = request.Semester,
SchoolYear = request.SchoolYear,
DateBegin = request.DateBegin.Date,
DateEnd = request.DateBegin.AddDays(subject.Lesson * 7).Date,
DateCreate = DateTime.UtcNow.AddHours(7),
DateUpdate = DateTime.UtcNow.AddHours(7),
};
_context.Courses.Add(course);
await _context.SaveChangesAsync();
return(new ApiSuccessResult <bool>("Tạo thành công"));
}
public async Task <IActionResult> Create(CourseDto course)
{
var request = new CreateCourseRequest(course);
await _courseService.Create(request);
return(RedirectToAction(nameof(Create)));
}
private static Response ModifyCourseResponse(CreateCourseRequest createCourseRequest)
{
DatabaseManager database = new DatabaseManager();
(MySqlDataReader reader, var Connection) = database.RunQuery($"UPDATE course_details SET coursename='{createCourseRequest.CourseName}' WHERE courseid='{createCourseRequest.UserId}' ");
if (reader != null)
{
Acknowledge ack = new Acknowledge()
{
Status = "OK", Reason = ""
};
if (reader.RecordsAffected > 0)
{
Connection.Close();
return(new Response()
{
Type = ResponseType.Acknowledge, Content = ack, Status = "OK"
});
}
}
Connection.Close();
return(new Response()
{
Content = null, Type = ResponseType.Acknowledge, Status = "FAIL"
});
}
public CreateCourseResponse Create(CreateCourseRequest createCourseRequest)
{
try
{
var course = _mapper.Map <Course>(createCourseRequest);
if (course == null)
{
return(new CreateCourseResponse()
{
IsSuccess = false,
});
}
_unitOfWork.CourseRepository.Create(course);
_unitOfWork.Save();
return(new CreateCourseResponse()
{
IsSuccess = true,
});
}
catch
{
return(new CreateCourseResponse()
{
IsSuccess = false,
});
}
}
public async Task <ActionResult> Post([FromBody] CreateCourseRequest request)
{
try {
var command = _mapper.Map <CreateCourseCommand>(request);
await _commandHandler.HandleAsync(command);
var query = new GetCourseDetailQuery {
Code = command.Code
};
var course = await _queryHandler.HandleAsync(query);
return(CreatedAtAction(nameof(Get), new { code = course.Code }, course));
} catch (Exception ex) {
// Check if exception is cause of duplicated key
if (ex.InnerException.Message.Contains("duplicate key"))
{
return(BadRequest(new {
title = $"Course with code '{request.Code.ToUpper()}' already exists.",
status = HttpStatusCode.BadRequest,
}));
}
return(BadRequest());
}
}
public async Task CreateAsync(CreateCourseRequest request)
{
if (request == null || string.IsNullOrEmpty(request.Name))
{
throw new ArgumentException("Name of course is required.");
}
await _coursesRepository.AddAsync(new Course { Name = request.Name });
}
public IHttpActionResult CreateCourse([FromBody] CreateCourseRequest request)
{
var response = _manager.CreateCourse(request);
if (!response.IsSuccessful)
{
return(BadRequest(response.ToString()));
}
return(Ok(response));
}
static void Main(string[] args)
{
string appId = ConfigurationManager.AppSettings["applicationId"];
string appKey = ConfigurationManager.AppSettings["applicationKey"];
string userId = ConfigurationManager.AppSettings["serviceUserId"];
string userKey = ConfigurationManager.AppSettings["serviceUserKey"];
string lmsUrl = ConfigurationManager.AppSettings["lmsUrl"];
ValenceAuthenticatorFactory authFactory = new ValenceAuthenticatorFactory(
appId, appKey, userId, userKey, lmsUrl);
ValenceAuthenticator auth = authFactory.CreateAuthenticator();
RestClient restClient = new RestClient("https://" + lmsUrl);
JsonSerializer serializer = new JsonSerializer();
CreateUserResponse userResponse;
using (StreamReader file = File.OpenText("user.json")) {
CreateUserData userData = (CreateUserData)serializer.Deserialize(file, typeof(CreateUserData));
CreateUserRequest userRequest = new CreateUserRequest(
userData,
restClient,
auth
);
userResponse = userRequest.SendRequest();
}
CreateCourseResponse courseResponse;
using (StreamReader file = File.OpenText("course.json")) {
CreateCourseData courseData = ( CreateCourseData )serializer.Deserialize(file, typeof(CreateCourseData));
CreateCourseRequest courseRequest = new CreateCourseRequest(
courseData,
restClient,
auth
);
courseResponse = courseRequest.SendRequest();
}
CreateEnrollData enrollData = new CreateEnrollData(
userResponse.UserId,
courseResponse.Identifier
);
CreateEnrollRequest enrollRequest = new CreateEnrollRequest(
enrollData,
restClient,
auth
);
enrollRequest.SendRequest();
Console.WriteLine("User, course, and enrollment created.");
Console.ReadKey();
}
public async Task <ActionResult> AddCourse(Guid authorId, CreateCourseRequest course)
{
if (course == null || !_coursesService.AuthorExists(authorId))
{
return(NotFound());
}
await _coursesService.AddCourseAsync(authorId, course);
return(Ok(course));
}
public async Task <IActionResult> Create(CreateCourseRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = await _courseService.CreateCourse(request);
if (result.IsSuccessed == false)
{
return(BadRequest(result));
}
return(Ok(result));
}
public static CourseEntity ToEntity(this CreateCourseRequest course)
{
if (course == null)
{
return(null);
}
return(new CourseEntity
{
AuthorId = course.AuthorId,
Title = course.Title,
Description = course.Description
});
}
public async Task CreatesNewCourseSavesToDb()
{
var mockRepo = new Mock <ICreateCourseRepo>();
var request = new CreateCourseRequest("This is a course", "https://www.google.com", "Most awesome course ever", UserLevel.Beginner);
var model = new CourseOverview(Guid.Empty, "", "", "", 2, UserLevel.Beginner, null);
mockRepo.Setup(p => p.Create(It.IsAny <CourseOverview>())).ReturnsAsync(model);
var controller = new CreateCourseController(mockRepo.Object);
controller.ObjectValidator = validator().Object;
var result = await controller.AddCourse(request);
mockRepo.Verify(m => m.Create(It.IsAny <CourseOverview>()), Times.Once);
}
public async Task AddCourseAsync(Guid authorId, CreateCourseRequest course)
{
if (authorId == Guid.Empty)
{
throw new ArgumentNullException(nameof(authorId));
}
if (course == null)
{
throw new ArgumentNullException(nameof(course));
}
course.AuthorId = authorId;
_context.Courses.Add(course.ToEntity());
await _context.SaveChangesAsync();
}
private async void createCourseButton_Click(object sender, RoutedEventArgs e)
{
if (string.IsNullOrWhiteSpace(courseNameTextBlock.Text))
{
return;
}
progressRing.isActive = true;
CreateCourseRequest request = new CreateCourseRequest()
{
CourseName = courseNameTextBlock.Text,
UserId = SettingsManager.Username,
Username = SettingsManager.FullName
};
if (IsModifyCourseType)
{
request.UserId = CourseID;
}
Object resp = await ConnectionManager.SendRequestAsync(request, IsModifyCourseType?RequestType.ModifyCourse : RequestType.CreateCourse, ResponseType.Acknowledge);
if (resp != null)
{
errorTextBlock.Text = ((JObject)resp).ToObject <Acknowledge>().Reason;
if (IsModifyCourseType)
{
AppNotificationManager.PushMessage(new AppNotification()
{
Message = "Course changed successfully."
});
}
else
{
AppNotificationManager.PushMessage(new AppNotification()
{
Message = "Course created successfully."
});
}
Close();
}
else
{
errorTextBlock.Text = "Connection Error";
}
progressRing.isActive = false;
}
public void canCreateCourse(CreateCourseRequest req, Section section)
{
//Seed data
DbRepository <Section> ._db.Add(section);
//Arrange
var sut = new ServiceStack();
req.SectionId = section.Id;
//Act
sut.CreateCourse(req);
//Assert
var actual = DbRepository <Section> ._db.Count == 1;
Assert.True(actual);
}
public async Task <IActionResult> CreateCourseAsync([FromForm] CreateCourseRequest request)
{
if (request != null && ModelState.IsValid)
{
var courseDto = mapper.Map <CreateCourseRequest, CourseDTO>(request);
courseDto.TeacherEmail = User.Identity.Name;
courseDto.UniversityId = (await teacherService
.GetTeacherInfoByEmailAsync(User.Identity.Name)).UniversityId;
courseDto.ImagePath = request.Image != null ?
await fileStorageService.SaveImageAsync(Guid.NewGuid() + request.Image.FileName, request.Image) : null;
await courseService.AddCourseAsync(courseDto);
return(Ok());
}
return(BadRequest());
}
public void CreateCourseTest()
{
_courseRepository.Setup(p => p.UnitOfWork.Commit()).Returns(Task.FromResult(true));
var cancellationToken = new System.Threading.CancellationToken();
var createCourseRequest = new CreateCourseRequest()
{
Name = "RabbitMq Overview",
Capacity = 20,
NumberOfStudents = 0,
LecturerId = new System.Guid("30A297B1-00F4-4634-AE70-988EAB8852C0")
};
var handler = new API.Commands.Handlers.CreateCourseHandler(_courseRepository.Object);
var response = handler.Handle(createCourseRequest, cancellationToken);
Assert.IsTrue(response.Result.ValidationResult.IsValid == true);
}
public async Task <IActionResult> CreateCourse(CreateCourseRequest createCourseRequest)
{
var tasks = createCourseRequest.Tasks;
var subject = new Subject()
{
Credits = createCourseRequest.Credits,
Title = createCourseRequest.Title
};
var subjectId = await _subjectService.CreateSubjectAsync(subject);
foreach (var task in tasks)
{
task.SubjectId = subjectId;
await _taskService.CreateTaskAsync(task);
}
return(Created("/subjects", "Successfully created"));
}
public async Task <IActionResult> CreateCourse([FromBody] CreateCourseRequest request)
{
try
{
if (!ModelState.IsValid)
{
return(StatusCode(StatusCodes.Status400BadRequest));
}
var courseId = await CommandService.CreateCourse();
return(Ok(new CreateCourseResponse {
CourseId = courseId
}));
}
catch (Exception ex)
{
// To do - Handle exceptions, log it and throw appropriate errors
return(StatusCode(StatusCodes.Status500InternalServerError, ex.Message));
}
}
public async Task <BasicResponse> Create(CreateCourseRequest request)
{
var response = new BasicResponse {
Status = Status.NotAuthorized
};
try
{
var course = request.Course.MapToModel(_mapper);
await _courseRepository.Create(course);
response.Status = Status.Ok;
}
catch (Exception ex)
{
response.Status = Status.InvalidData;
response.Message = ex.Message;
}
return(response);
}
private static Response CreateCourseResponse(CreateCourseRequest createCourseRequest)
{
Acknowledge ack = new Acknowledge()
{
Status = "FAIL", Reason = "Course Creation Failed."
};
Response resp = new Response()
{
Type = ResponseType.Acknowledge, Status = "OK", Content = ack
};
string query = String.Format("INSERT INTO course_details (courseid, coursename, authorid) VALUES (uuid(),'{0}','{1}')", RefineContent(createCourseRequest.CourseName), createCourseRequest.UserId);
DatabaseManager database = new DatabaseManager();
(MySqlDataReader reader, var Connection) = database.RunQuery(query);
if (reader != null && reader.RecordsAffected > 0)
{
ack.Status = "OK";
ack.Reason = "Success";
}
Connection.Close();
return(resp);
}
public async Task CheckAfterAddingCourse()
{
var req = new CreateCourseRequest {
Name = "Course Test 1232222"
};
var res = await _coursesController.CreateCourse(req);
var createOkRes = res as OkObjectResult;
Assert.NotNull(createOkRes);
Assert.Equal(200, createOkRes.StatusCode);
var courses = await _coursesController.GetAllCourses();
var getOkRes = courses as OkObjectResult;
Assert.NotNull(getOkRes);
Assert.Equal(200, getOkRes.StatusCode);
var result = (IEnumerable <CourseResponse>)getOkRes.Value;
Assert.Contains(req.Name, result.Select(x => x.Name));
}
public CourseResponse CreateCourse(CreateCourseRequest request)
{
var response = new CreateCourseRequestValidator().Validate(request).ToResponse <CourseResponse>();
if (!response.IsSuccessful)
{
return(response);
}
var course = new Course()
{
CourseName = request.CourseName,
CourseDescription = request.CourseDescription,
Semester = request.Semester,
};
var programsCourses = request.Programs
.Select(x => new ProgramsCourses
{
Course = course,
ProgramId = x.ProgramId,
IsMandatory = x.IsMandatory,
}).ToList();
try
{
response.Course = _coursesRepository.CreateCourse(course, programsCourses, request.Prerequisites);
}
catch (Exception ex)
{
_logger.LogException(ex);
response.IsSuccessful = false;
response.Errors.Add("An error has occurred while inserting course");
}
return(response);
}
public static Course FromRequest(CreateCourseRequest request)
{
return(Create(CourseIdMother.Create(request.Id), CourseNameMother.Create(request.Name), CourseDurationMother.Create(request.Duration)));
}
public async Task <CreateCourseResponse> CreateCourse(
[FromServices] IMediator mediator,
[FromBody] CreateCourseRequest command)
{
return(await mediator.Send(command));
}
