public int? AddCourse(CourseDto newCourse)
{
try
{
var course = CourseDto.UnMap(newCourse);
return new Repository<CourseModel>().Add(course);
}
catch (Exception ex)
{
Logger.Error("Error : CourseService.AddCourse - {0}", ex.Message);
return null;
}
}
public void CallSaverSaveChangesMethodOnce_WhenInvokedWithValidParameters()
{
//Arrange
var coursesMock = new Mock <IRepository <Course> >();
var studentCoursesMock = new Mock <IRepository <StudentCourse> >();
var mapperMock = new Mock <IMappingProvider>();
var saverMock = new Mock <ISaver>();
var courseDto = new CourseDto()
{
Id = new Guid("12367a78-faf1-40c9-abcd-0c3131a03312"),
Name = "DSA",
Credits = 5,
LecturerName = "Sasho Dikov"
};
var course = new Course()
{
Id = new Guid("12367a78-faf1-40c9-abcd-0c3131a03312"),
Name = "DSA",
Credits = 5,
LecturerName = "Sasho Dikov"
};
mapperMock
.Setup(x => x.MapTo <Course>(courseDto))
.Returns(course);
var courseService = new CourseService(
coursesMock.Object,
studentCoursesMock.Object,
mapperMock.Object,
saverMock.Object);
//Act
courseService.AddCourse(courseDto);
//Assert
saverMock.Verify(x => x.SaveChanges(), Times.Once);
}
public void Can_add_new_course()
{
new CourseService();
#region Arrange
var newCourse = new CourseDto
{
CreationDate = DateTime.Now,
CourseType = CourseTypeModelDto.Map(TestCourseType),
Group = new GroupModelDto
{
GroupName = "added test",
GroupType = GroupTypeModelDto.Map(TestGroupType)
},
Logo = "test/jpg",
Name = "test add",
ShoutBox = new ShoutboxModelDto()
};
#endregion
#region Act
int? id = new CourseService().AddCourse(newCourse);
CourseDto testingAddedCourse=null;
if (id.HasValue)
{
testingAddedCourse = new CourseService().GetById(id.Value);
}
#endregion
#region Assert
Assert.That(testingAddedCourse,Is.Not.Null);
if (testingAddedCourse != null)
{
Assert.That(testingAddedCourse.Name, Is.EqualTo("test add"));
Assert.That(testingAddedCourse.Group.GroupName, Is.EqualTo("added test"));
}
#endregion
}
public async Task <IActionResult> OnGetAsync([ModelBinder(Name = "CourseId")] CourseDto course)
{
if (course != null)
{
AddOrUpdateCourseDto = new AddOrUpdateCourseDto
{
Desc = course.Desc,
Id = course.Id,
Name = course.Name,
UserId = course.UserId
};
}
else
{
AddOrUpdateCourseDto = new AddOrUpdateCourseDto
{
UserId = CurUserId
};
}
return(Page());
}
public async Task <IHttpActionResult> PostCourse(Course course)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.Courses.Add(course);
await db.SaveChangesAsync();
db.Entry(course).Reference(x => x.Category).Load();
var dto = new CourseDto()
{
Id = course.Id,
CourseGUID = course.CourseGUID,
CourseName = course.CourseName,
CatName = course.Category.CatName
};
return(CreatedAtRoute("DefaultApi", new { id = course.Id }, dto));
}
public async Task <ActionResult <CourseDto> > Put([FromBody] CourseDto item)
{
try
{
if (item == null || item.Id == null)
{
return(BadRequest());
}
if (await _supervisor.UpdateCourseAsync(item))
{
return(Ok(item));
}
else
{
return(NotFound());
}
}
catch (Exception ex)
{
return(StatusCode(500, ex));
}
}
public void UpdateCourse(int id, CourseDto courseDto)
{ //Validate the model first
if (!ModelState.IsValid)
{
throw new HttpResponseException(HttpStatusCode.BadRequest);
}
else
{
var courseDb = _DbContext.Courses.SingleOrDefault(c => c.CourseID == id);
if (courseDb == null)
{
throw new HttpResponseException(HttpStatusCode.NotFound);
}
else
{
Mapper.Map <CourseDto, Course>(courseDto, courseDb);
_DbContext.SaveChanges();
}
;
}
}
public async Task <IActionResult> GetCourse(int id)
{
try
{
CourseDto course = await _courseServices.GetCourseByIdAsync(id);
if (course == null)
{
return(NotFound("no course found"));
}
return(Ok(course));
}
catch (NotFoundException ex)
{
return(NotFound(ex.Message));
}
catch (Exception ex)
{
_logger.LogCritical($"GetCourse() Error: {ex}");
return(StatusCode(500, "Internal Server Error"));
}
}
public IActionResult Post([FromBody] CourseDto course)
{
//Check if the course exist
if (!ModelState.IsValid)
{
return(StatusCode(StatusCodes.Status400BadRequest, new
{
Message = "Course Name is required"
}));
}
var newCourseModel = _mapper.Map <Course>(course);
var result = _courseService.SaveCourse(newCourseModel);
if (result <= 0)
{
return(StatusCode(StatusCodes.Status400BadRequest, new
{
Message = "Chapter could not be saved."
}));
}
return(CreatedAtAction("Get", new { id = newCourseModel.Id }, _mapper.Map <CourseDto>(newCourseModel)));
}
// Edit existing question
public QuestionEditor(IDataSource db, CourseDto course, QuestionDto question)
{
InitializeComponent();
Db = db;
_course = course;
_newQuestion = false;
_question = question;
lblQuestion.Text = question.Text;
lblCorrectAnswer.Text = question.RightAnswer;
lblWrongAnswer1.Text = question.WrongAnswer1;
lblWrongAnswer2.Text = question.WrongAnswer2;
lblWrongAnswer3.Text = question.WrongAnswer3;
if (question.Difficulty == 2)
{
rbtnExtreme.Checked = true;
}
if (question.Difficulty == 1)
{
rbtnHard.Checked = true;
}
}
public void Create(CourseDto courseDto, int specializationId, string tutorId)
{
if (courseDto.Name == null || tutorId == null || tutorId.Equals("") ||
courseDto.Name.Equals("") || courseDto.StartDate == null || courseDto.EndDate == null ||
courseDto.Description == null || courseDto.Description.Equals("") ||
specializationId == 0)
{
throw new ValidationException("Something is wrong");
}
Course course = new Course
{
Name = courseDto.Name,
EndDate = courseDto.EndDate,
StartDate = courseDto.StartDate,
Subscribers = 0,
TutorId = tutorId,
Description = courseDto.Description,
Specialization = Database.Specializations.Get(specializationId)
};
Database.Courses.Create(course);
Database.Save();
}
public IActionResult CreateCourse(CourseDto courseDto)
{
if (!ModelState.IsValid)
{
// return 422
return(new Helpers.UnprocessableEntityObjectResult(ModelState));
}
try
{
// save
var courseFromRepo = _courseRepository.CreateCourse(courseDto);
var courseToReturn = _mapper.Map <CourseDto>(courseFromRepo);
return(Ok(courseToReturn));
}
catch (AppException ex)
{
// return error message if there was an exception
return(BadRequest(new { message = ex.Message }));
}
}
public async Task <IActionResult> CreateCourseAsync([FromBody] CourseDto courseDto)
{
if (courseDto.Id != Guid.Empty)
{
return(Problem("Id cannot be used in request", statusCode: (int)HttpStatusCode.BadRequest));
}
if (courseDto.Enrolled != 0)
{
return(Problem("Enrolled cannot be set in request", statusCode: (int)HttpStatusCode.BadRequest));
}
var commandResult = await Mediator.Send(courseDto.ToCreateCommand());
if (commandResult.Status == CommandResultStatus.DuplicatedEntity)
{
return(Problem(detail: commandResult.Message, statusCode: (int)HttpStatusCode.UnprocessableEntity));
}
var course = commandResult.Entity.ToCourseDto();
return(CreatedAtAction(nameof(GetByCourseIdAsync), new { courseId = course.Id }, course));
}
public async Task <ActionResult <CourseDto> > PostCourse(CourseDto courseDto)
{
//_context.Course.Add(course);
//await _context.SaveChangesAsync();
if (!ModelState.IsValid)
{
return(BadRequest());
}
Course course = m_Mapper.Map <Course>(courseDto);
await m_Uow.CourseRepository.AddAsync(course);
bool bSaveOk = await m_Uow.CourseRepository.SaveAsync();
if (!bSaveOk)
{
return(StatusCode(500));
}
return(CreatedAtAction("GetCourse", new { id = courseDto.CourseId }, courseDto));
}
public bool Merge(CourseDto courseDto)
{
var changed = false;
DateTime? newDatePublished = courseDto.DatePublishedParsed;
if (DatePublished != newDatePublished)
{
DatePublished = newDatePublished;
changed = true;
}
CourseLevel newLevel = courseDto.Level.ToEnum();
if (Level == newLevel)
{
return changed;
}
Level = newLevel;
return true;
}
public int Update(CourseDto courseModel, List <IFormFile> files, string rootPath)
{
if (files != null)
{
var file = files.FirstOrDefault();
var path = Path.Combine(_hostingEnvironment.ContentRootPath, "wwwroot\\" + file.FileName);
using (FileStream filestream = File.Create(path))
{
file.CopyToAsync(filestream);
filestream.FlushAsync();
courseModel.ImagePath = "//" + file.FileName;
}
}
else
{
var course = GetByID(courseModel.CourseID, rootPath);
courseModel.ImagePath = course.ImagePath;
}
var courseEntity = Mapper.Map <CourseDto, Course>(courseModel);
var updateCourseResult = _repo.Update(courseEntity);
return(updateCourseResult);
}
public async Task <Course> Update(CourseDto courseDto)
{
Course course = await _courseRepository.GetById(courseDto.CourseId);
if (course != null)
{
_mapper.Map(courseDto, course);
course.Validate(course, new CourseValidator());
_notifications.AddNotifications(course.ValidationResult);
if (!_notifications.HasNotifications)
{
await Put(course);
}
}
else
{
_notifications.AddNotification("404", "CourseId", "Course with id = " + courseDto.CourseId + " not found");
}
return(course);
}
public async Task <IActionResult> Put(int?id, [FromBody] CourseDto courseToEdit)
{
if (courseToEdit == null || courseToEdit.Id != id)
{
return(BadRequest());
}
var course = _context.Courses.Find(id);
if (course == null)
{
return(NotFound());
}
course.Title = courseToEdit.Title;
course.Credits = courseToEdit.Credits;
course.DepartmentID = courseToEdit.DepartmentID;
_context.Courses.Update(course);
await _context.SaveChangesAsync();
return(NoContent());
}
public void ThrowArgumentNullException_WhenInvokedWithInvalidNullCourseDtoParameter()
{
//Arrange
var coursesMock = new Mock <IRepository <Course> >();
var studentCoursesMock = new Mock <IRepository <StudentCourse> >();
var mapperMock = new Mock <IMappingProvider>();
var saverMock = new Mock <ISaver>();
var courseDto = new CourseDto()
{
Id = new Guid("12367a78-faf1-40c9-abcd-0c3131a03312"),
Name = "DSA",
Credits = 5,
LecturerName = "Sasho Dikov"
};
var course = new Course()
{
Id = new Guid("12367a78-faf1-40c9-abcd-0c3131a03312"),
Name = "DSA",
Credits = 5,
LecturerName = "Sasho Dikov"
};
mapperMock
.Setup(x => x.MapTo <Course>(courseDto))
.Returns(course);
var courseService = new CourseService(
coursesMock.Object,
studentCoursesMock.Object,
mapperMock.Object,
saverMock.Object);
//Act && Assert
Assert.ThrowsException <ArgumentNullException>(() => courseService.AddCourse(null));
}
public IActionResult UpdateCourseForAuthor(
[FromRoute] Guid authorId,
[FromRoute] Guid courseId,
[FromBody] CourseForUpdateDto courseForUpdate)
{
if (!AuthorExists(authorId))
{
return(NotFound());
}
var courseFromRepo = _courseLibraryRepository.GetCourse(authorId, courseId);
if (courseFromRepo == null)
{
Course courseToAdd = _mapper.Map <Course>(courseForUpdate);
courseToAdd.Id = courseId;
_courseLibraryRepository.AddCourse(authorId, courseToAdd);
_courseLibraryRepository.Save();
CourseDto courseToReturn = _mapper.Map <CourseDto>(courseToAdd);
return(CreatedAtRoute(
routeName: "GetCourseForAuthor",
routeValues: new { authorId = authorId, courseId = courseToReturn.Id },
value: courseToReturn
));
}
// Maps the values from the source to destination
// This allows us to update the values with out doing it piecewise manually
_mapper.Map(source: courseForUpdate, destination: courseFromRepo);
_courseLibraryRepository.UpdateCourse(courseFromRepo);
_courseLibraryRepository.Save();
return(NoContent());
}
public async Task <ApiResponse <Course> > CreateCourse(CourseDto courseDto)
{
var response = new ApiResponse <Course>();
try
{
//check course Exists
var isExistCourse = await _courseRepository.CountAsync(i => i.Name == courseDto.Name);
if (isExistCourse != 0)
{
response.Success = false;
response.Errors.Add("Course Already Exists");
return(response);
}
var id = Guid.NewGuid();
//create new course
var course = Mapper.Map <Course>(courseDto);
course.Id = id;
//course.CreatedBy = course.Id;
course.CreatedDate = DateTime.Now;
//course.Roles = courseRoles;
course.IsActive = true;
await _courseRepository.AddAsyn(course);
response.Success = true;
}
catch (Exception ex)
{
response.Success = false;
response.Errors.Add(ex.Message);
}
return(response);
}
//todo poprawic updatowanie learning materialsow bo teraz jest burdel :X 2 azy sciagam niepotrzebnie encje
public bool Update(CourseDto updatedCourse, bool reupload)
{
try
{
using (var session = DataAccess.OpenSession())
{
if (reupload)
{
var originalCourse = session.Load <CourseModel>(updatedCourse.ID);
var course = CourseDto.UnMap(updatedCourse);
originalCourse.CourseType = session.Load <CourseTypeModel>(updatedCourse.CourseTypeId);
originalCourse.Description = course.Description;
originalCourse.Logo = course.Logo;
originalCourse.Name = course.Name;
originalCourse.News = course.News;
originalCourse.Password = course.Password;
originalCourse.ShortDescription = course.ShortDescription;
session.Update(originalCourse);
session.Flush();
return(true);
}
else
{
session.Update(CourseDto.UnMap(updatedCourse));
session.Flush();
return(true);
}
}
}
catch (Exception ex)
{
Logger.Error("Error : CourseService.Update - {0}", ex.Message);
return(false);
}
}
/// <summary>
/// Create course
/// </summary>
/// <param name="course"></param>
/// <returns></returns>
public CourseDto CreateCourse(CourseDto course)
{
logger.Info("Service received request for Course {@courseData} creation", course);
Course newCourse = new Course()
{
Name = course.Name,
ColloqialName = course.ColloqialName
};
// NOTE Should I inspect beforehand or just shoot
// and handle error in case of unsuccessful insertion
CreateCourse(newCourse);
CourseDto courseDto = new CourseDto()
{
Name = newCourse.Name,
ColloqialName = newCourse.ColloqialName,
Id = newCourse.Id
};
logger.Info("Course creation succesful");
return(courseDto);
}
public bool AddCourse(CourseDto courseDto)
{
try
{
var course = new Course
{
CourseName = courseDto.CourseName,
Fee = courseDto.Fee,
CTimings = courseDto.CTimings,
CourseDesc = courseDto.CourseDesc
};
context.Course.Add(course);
int result = context.SaveChanges();
if (result > 0)
{
return(true);
}
return(false);
}
catch (Exception)
{
throw;
}
}
public ServiceResponse <CourseDto> Insert(CourseDto modelDto)
{
var response = new ServiceResponse <CourseDto>();
try
{
var model = new Course();
model.Title = modelDto.Title;
model.Slug = modelDto.Slug;
model.Description = modelDto.Description;
model.VideoUrl = modelDto.VideoUrl;
model.DateAdded = DateTime.Now;
_repository.Insert(model);
response.IsSuccessful = true;
}
catch (Exception)
{
response.ExceptionMessage = ErrorCodes.BilinmeyenHata.Text;
response.IsSuccessful = false;
}
return(response);
}
public IActionResult UpdateCourse([FromBody] CourseDto courseDto)
{
try
{
if (!ModelState.IsValid)
{
// return 422
return(new Helpers.UnprocessableEntityObjectResult(ModelState));
}
_courseRepository.UpdateCourse(courseDto);
if (!_courseRepository.Save())
{
throw new AppException("Updating course failed on save.");
}
return(Ok());
}
catch (AppException ex)
{
return(BadRequest(new { message = ex.Message }));
}
}
public bool InsertCourse(string userId, CourseDto course)
{
try
{
//Validate user
if (_userRepository.IsAuthenticated(userId))
{
//Validate Model
ICollection <ValidationResult> results;
if (IsValidModel(course, out results))
{
//Call Repository
if (_courseRepository.InsertCourse(course))
{
//Save
if (_courseRepository.Save())
{
//Success
return(true);
}
_loggingService.Info("Failed To Save");
}
_loggingService.Info("UserRepository Failed Insert");
}
_loggingService.Info("Model Validation Failed: " + course);
}
_loggingService.Info("UserId Authenticated Failed: " + userId);
}
catch (Exception ex)
{
//Error
_loggingService.Error("An error has occurred", ex);
}
//Fail
return(false);
}
protected override async Task OnInitAsync()
{
Course = await Client.GetDetails(CourseID);
}
//todo poprawic updatowanie learning materialsow bo teraz jest burdel :X 2 azy sciagam niepotrzebnie encje
public bool Update(CourseDto updatedCourse,bool reupload)
{
try
{
using (var session = DataAccess.OpenSession())
{
if (reupload)
{
var originalCourse = session.Load<CourseModel>(updatedCourse.ID);
var course = CourseDto.UnMap(updatedCourse);
originalCourse.CourseType = session.Load<CourseTypeModel>(updatedCourse.CourseTypeId);
originalCourse.Description = course.Description;
originalCourse.Logo = course.Logo;
originalCourse.Name = course.Name;
originalCourse.News = course.News;
originalCourse.Password = course.Password;
originalCourse.ShortDescription = course.ShortDescription;
session.Update(originalCourse);
session.Flush();
return true;
}
else
{
session.Update(CourseDto.UnMap(updatedCourse));
session.Flush();
return true;
}
}
}
catch (Exception ex)
{
Logger.Error("Error : CourseService.Update - {0}", ex.Message);
return false;
}
}
public async Task <ActionResult <CourseDto> > PutCourse(int id, CourseInputDto input)
{
DateTime?datetime = null;
var users = await _context.Users.Where(x => x.FullName != null).ToListAsync();
var currency = await _context.Currencies.Where(x => !x.VirtualDeleted && x.IsActive).FirstOrDefaultAsync();
var defaultCurrency = await _context.Currencies.Where(x => !x.VirtualDeleted).FirstOrDefaultAsync();
var lessons = await _context.Lessons.Where(x => !x.VirtualDeleted && x.CourseId == id).ToListAsync();
var typeOfPacket = await _context.TypeOfPackets.FirstOrDefaultAsync(x => !x.VirtualDeleted && x.Id == input.TypeOfPacketId);
var course = await _context.Courses.FindAsync(id);
course.ExamDate = DateTimeString.TryParsingDate(input.ExamDate, false);
course.InChargeId = input.InChargeId;
course.CustomerId = input.CustomerId;
course.LessonPeriod = input.LessonPeriod;
course.Note = input.Note;
course.RemainingMoney = input.TotalAmount - (course.TotalAmount - course.RemainingMoney);
course.StartCourse = DateTimeString.TryParsingDate(input.StartCourse, false);
course.TotalAmount = input.TotalAmount;
course.CurrencyId = currency == null ? defaultCurrency?.Id : currency.Id;
course.PeroidBeforeSendEmailId = input.PeroidBeforeSendEmailId;
course.TypeOfExamId = input.TypeOfExamId;
course.TypeOfPacketId = input.TypeOfPacketId;
course.UpdatedUserId = input.UserId;
course.UpdatedDate = DateTime.Now;
if (typeOfPacket.LessonsCount > lessons.Count)
{
var lastLesson = await _context.Lessons.Where(x => !x.VirtualDeleted &&
x.CourseId == course.Id).OrderByDescending(x => x.Number).FirstOrDefaultAsync();
var number = lastLesson.Number;
course.Status = Domain.Enums.CourseStatus.Started;
for (int i = 0; i < typeOfPacket.LessonsCount - lessons.Count; i++)
{
number += 1;
var lesson = new Lesson()
{
Date = datetime,
Time = datetime,
InChargeId = input.InChargeId,
CourseId = id,
LessonPeriod = input.LessonPeriod,
Note = input.Note,
Number = number,
Status = Domain.Enums.LessonStatus.NotStarted,
CreatedDate = DateTime.Now,
CreatedUserId = input.UserId
};
_context.Lessons.Add(lesson);
}
}
else if (!lessons.Any(x => x.Status != Domain.Enums.LessonStatus.Active || x.Status != Domain.Enums.LessonStatus.NotStarted))
{
course.Status = Domain.Enums.CourseStatus.Finished;
}
_context.Entry(course).State = EntityState.Modified;
var user = await _context.Users.FirstOrDefaultAsync(x => x.Id == input.UserId);
var log = new Log()
{
DateTime = DateTime.Now,
TypeFullName = typeof(Course).FullName,
Content = "@userName@updateAction@objTitle",
TypeId = course.Id,
UserId = user.Id
};
_context.Logs.Add(log);
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CourseExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
var result = new CourseDto();
//var result = new CourseDto()
//{
// Id = course.Id,
// ExamDate = course.ExamDate.HasValue ? course.ExamDate.Value.ToString("G") : "",
// ExamDateInDays = course.ExamDate.HasValue ? (course.ExamDate.Value - DateTime.Now.Date).TotalDays.ToString() : "0",
// InChargeId = course.InChargeId,
// NextLessonDate = lessons.Any() ? lessons.OrderBy(x => x.Date).FirstOrDefault().Date.Value.ToString("G") : "",
// NextLessonTime = lessons.Any() ? lessons.OrderBy(x => x.Date).OrderBy(x => x.Time).FirstOrDefault().Time.Value.ToString("T") : "",
// InChargeName = users.SingleOrDefault(y => y.Id == course.InChargeId).FullName,
// CustomerId = course.CustomerId.HasValue ? course.CustomerId.Value : 0,
// LessonPeriod = course.LessonPeriod.ToString(),
// Note = course.Note,
// RemainingMoney = course.RemainingMoney,
// StartCourse = course.StartCourse.HasValue ? course.StartCourse.Value.ToString("G") : "",
// Status = course.Status.ToString(),
// TotalAmount = course.TotalAmount,
// Currency = course.Currency == null ? new CurrencyDto() : new CurrencyDto()
// {
// Id = course.Currency.Id,
// Name = course.Currency.Name,
// ForeignName = course.Currency.ForeignName,
// IsActive = course.Currency.IsActive,
// Symbol = course.Currency.Symbol,
// },
// PeroidBeforeSendEmail = course.PeroidBeforeSendEmail == null ? new PeroidBeforeSendEmailDto() : new PeroidBeforeSendEmailDto()
// {
// Id = course.PeroidBeforeSendEmail.Id,
// Name = course.PeroidBeforeSendEmail.Name,
// ForeignName = course.PeroidBeforeSendEmail.ForeignName,
// Hours = course.PeroidBeforeSendEmail.Hours,
// },
// TypeOfExam = course.TypeOfExam == null ? new TypeOfExamDto() : new TypeOfExamDto()
// {
// Id = course.TypeOfExam.Id,
// Name = course.TypeOfExam.Name,
// ForeignName = course.TypeOfExam.ForeignName,
// Cost = course.TypeOfExam.Cost
// },
// TypeOfPacket = course.TypeOfPacket == null ? new TypeOfPacketDto() : new TypeOfPacketDto()
// {
// Id = course.TypeOfPacket.Id,
// Name = course.TypeOfPacket.Name,
// ForeignName = course.TypeOfPacket.ForeignName,
// Cost = course.TypeOfPacket.Cost
// }
//};
return(result);
}
public async Task <ActionResult <IEnumerable <CourseDto> > > GetCourses(string searchText = null
, string code = null
, string title = null
, double?unit = null
/*, int pageNumber=1, int pageSize=7*/)
{
// var courses = _context.Courses.Select(CourseDto.AsCourseDto);
List <Expression <Func <CourseDto, bool> > > filters = null;
if (String.IsNullOrEmpty(searchText) &&
(String.IsNullOrEmpty(code)) &&
(String.IsNullOrEmpty(title)) &&
(unit == null)
)
{
// return null;
}
else
{
filters = new List <Expression <Func <CourseDto, bool> > >();
if (!String.IsNullOrEmpty(searchText))
{
if (searchText.CompareTo("*") != 0 && searchText.CompareTo("%") != 0)
{
filters.Add(x => x.Id.ToString().Contains(searchText));
}
}
if (!String.IsNullOrEmpty(code))
{
filters.Add(x => x.Code == code);
}
if (!String.IsNullOrEmpty(title))
{
filters.Add(x => x.Title == title);
}
if (unit != null)
{
filters.Add(x => x.Unit == unit);
}
}
//sort
//return courses.OrderBy(o => o.Id).Skip(((pageNumber - 1) * pageSize)).Take(pageSize);
// OnSelectQuery(ref courses);
// return await courses.ToListAsync();
if (filters == null)
{
return(await courseService.GetCourseDtoesAsync(CourseDto.IncludeNavigations()));
}
else
{
return(await courseService.GetCourseDtoesAsync(CourseDto.IncludeNavigations(), filters.ToArray()));
}
}
public async Task <ActionResult <CourseDto> > DeleteCourse(int id, string userId)
{
DateTime?datetime = null;
var users = await _context.Users.Where(x => x.FullName != null).ToListAsync();
var course = await _context.Courses.Where(x => x.Id == id).Include(x => x.InCharge)
.Include(x => x.Currency)
.Include(x => x.Customer)
.Include(x => x.TypeOfExam)
.Include(x => x.TypeOfPacket)
.Include(x => x.PeroidBeforeSendEmail).FirstOrDefaultAsync();;
if (course == null)
{
return(NotFound());
}
course.DeletedDate = DateTime.Now;
course.DeletedUserId = userId;
course.VirtualDeleted = true;
_context.Entry(course).State = EntityState.Modified;
var user = await _context.Users.FirstOrDefaultAsync(x => x.Id == userId);
var log = new Log()
{
DateTime = DateTime.Now,
TypeFullName = typeof(Course).FullName,
Content = "@userName@deleteAction@objTitle",
TypeId = course.Id,
UserId = user.Id
};
_context.Logs.Add(log);
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CourseExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
var result = new CourseDto()
{
Id = course.Id,
ExamDate = course.ExamDate.HasValue ? course.ExamDate.Value.ToString("G") : "",
ExamDateInDays = course.ExamDate.HasValue ? (DateTime.Now.Date - course.ExamDate.Value).TotalDays.ToString() : "0",
InChargeId = course.InChargeId,
InChargeName = users.SingleOrDefault(y => y.Id == course.InChargeId).FullName,
CustomerId = course.CustomerId.HasValue ? course.CustomerId.Value : 0,
LessonPeriod = course.LessonPeriod.ToString(),
Note = course.Note,
RemainingMoney = course.RemainingMoney,
StartCourse = course.StartCourse.HasValue ? course.StartCourse.Value.ToString("G") : "",
Status = course.Status.ToString(),
TotalAmount = course.TotalAmount,
Currency = new CurrencyDto()
{
Id = course.Currency.Id,
Name = course.Currency.Name,
ForeignName = course.Currency.ForeignName,
IsActive = course.Currency.IsActive,
Symbol = course.Currency.Symbol,
},
PeroidBeforeSendEmail = new PeroidBeforeSendEmailDto()
{
Id = course.PeroidBeforeSendEmail.Id,
Name = course.PeroidBeforeSendEmail.Name,
ForeignName = course.PeroidBeforeSendEmail.ForeignName,
Hours = course.PeroidBeforeSendEmail.Hours,
},
TypeOfExam = new TypeOfExamDto()
{
Id = course.TypeOfExam.Id,
Name = course.TypeOfExam.Name,
ForeignName = course.TypeOfExam.ForeignName,
Cost = course.TypeOfExam.Cost
},
TypeOfPacket = new TypeOfPacketDto()
{
Id = course.TypeOfPacket.Id,
Name = course.TypeOfPacket.Name,
ForeignName = course.TypeOfPacket.ForeignName,
Cost = course.TypeOfPacket.Cost
}
};
return(result);
}
public async Task <ActionResult <CourseDto> > PostCourse(CourseInputDto input)
{
DateTime?datetime = null;
var users = await _context.Users.Where(x => x.FullName != null).ToListAsync();
var currency = await _context.Currencies.Where(x => !x.VirtualDeleted && x.IsActive).FirstOrDefaultAsync();
var defaultCurrency = await _context.Currencies.Where(x => !x.VirtualDeleted).FirstOrDefaultAsync();
try
{
var typeOfPacket = await _context.TypeOfPackets.FirstOrDefaultAsync(x => !x.VirtualDeleted && x.Id == input.TypeOfPacketId);
var course = new Course()
{
ExamDate = DateTimeString.TryParsingDate(input.ExamDate, false),
InChargeId = input.InChargeId,
CustomerId = input.CustomerId,
LessonPeriod = input.LessonPeriod,
Note = input.Note,
StartCourse = DateTimeString.TryParsingDate(input.StartCourse, false),
TotalAmount = input.TotalAmount,
CurrencyId = currency == null ? defaultCurrency?.Id : currency.Id,
PeroidBeforeSendEmailId = input.PeroidBeforeSendEmailId,
TypeOfExamId = input.TypeOfExamId,
TypeOfPacketId = input.TypeOfPacketId,
CreatedDate = DateTime.Now,
CreatedUserId = input.UserId
};
course.RemainingMoney = course.TotalAmount;
course.Status = Domain.Enums.CourseStatus.NotStarted;
_context.Courses.Add(course);
await _context.SaveChangesAsync();
for (int i = 0; i < typeOfPacket.LessonsCount; i++)
{
var lesson = new Lesson()
{
Date = datetime,
Time = datetime,
InChargeId = input.InChargeId,
CourseId = course.Id,
Number = i + 1,
LessonPeriod = input.LessonPeriod,
Note = input.Note,
Status = Domain.Enums.LessonStatus.NotStarted,
CreatedDate = DateTime.Now,
CreatedUserId = input.UserId
};
_context.Lessons.Add(lesson);
}
var user = await _context.Users.FirstOrDefaultAsync(x => x.Id == input.UserId);
var log = new Log()
{
DateTime = DateTime.Now,
TypeFullName = typeof(Course).FullName,
Content = "@userName@addAction@objTitle",
TypeId = course.Id,
UserId = user.Id
};
_context.Logs.Add(log);
await _context.SaveChangesAsync();
course = await _context.Courses.Where(x => x.Id == course.Id).Include(x => x.InCharge)
.Include(x => x.Currency)
.Include(x => x.Customer)
.Include(x => x.TypeOfExam)
.Include(x => x.TypeOfPacket)
.Include(x => x.PeroidBeforeSendEmail).FirstOrDefaultAsync();
var result = new CourseDto()
{
Id = course.Id,
ExamDate = course.ExamDate.HasValue ? course.ExamDate.Value.ToString("G") : "",
ExamDateInDays = course.ExamDate.HasValue ? (DateTime.Now.Date - course.ExamDate.Value).TotalDays.ToString() : "0",
InChargeId = course.InChargeId,
InChargeName = users.SingleOrDefault(y => y.Id == course.InChargeId).FullName,
CustomerId = course.CustomerId.HasValue ? course.CustomerId.Value : 0,
LessonPeriod = course.LessonPeriod.ToString(),
Note = course.Note,
RemainingMoney = course.RemainingMoney,
StartCourse = course.StartCourse.HasValue ? course.StartCourse.Value.ToString("G") : "",
Status = course.Status.ToString(),
TotalAmount = course.TotalAmount,
Currency = course.Currency == null ? new CurrencyDto() : new CurrencyDto()
{
Id = course.Currency.Id,
Name = course.Currency.Name,
ForeignName = course.Currency.ForeignName,
IsActive = course.Currency.IsActive,
Symbol = course.Currency.Symbol,
},
PeroidBeforeSendEmail = course.PeroidBeforeSendEmail == null ? new PeroidBeforeSendEmailDto() : new PeroidBeforeSendEmailDto()
{
Id = course.PeroidBeforeSendEmail.Id,
Name = course.PeroidBeforeSendEmail.Name,
ForeignName = course.PeroidBeforeSendEmail.ForeignName,
Hours = course.PeroidBeforeSendEmail.Hours,
},
TypeOfExam = course.TypeOfExam == null ? new TypeOfExamDto() : new TypeOfExamDto()
{
Id = course.TypeOfExam.Id,
Name = course.TypeOfExam.Name,
ForeignName = course.TypeOfExam.ForeignName,
Cost = course.TypeOfExam.Cost
},
TypeOfPacket = course.TypeOfPacket == null ? new TypeOfPacketDto() : new TypeOfPacketDto()
{
Id = course.TypeOfPacket.Id,
Name = course.TypeOfPacket.Name,
ForeignName = course.TypeOfPacket.ForeignName,
Cost = course.TypeOfPacket.Cost
}
};
return(result);
}
catch (Exception ex)
{
return(null);
}
}
